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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING. If not, write to
21the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22Boston, MA 02110-1301, USA. */
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
43/* The various kinds of conversion. */
44
45typedef enum conversion_kind {
46 ck_identity,
47 ck_lvalue,
48 ck_qual,
49 ck_std,
50 ck_ptr,
51 ck_pmem,
52 ck_base,
53 ck_ref_bind,
54 ck_user,
55 ck_ambig,
56 ck_rvalue
57} conversion_kind;
58
59/* The rank of the conversion. Order of the enumerals matters; better
60 conversions should come earlier in the list. */
61
62typedef enum conversion_rank {
63 cr_identity,
64 cr_exact,
65 cr_promotion,
66 cr_std,
67 cr_pbool,
68 cr_user,
69 cr_ellipsis,
70 cr_bad
71} conversion_rank;
72
73/* An implicit conversion sequence, in the sense of [over.best.ics].
74 The first conversion to be performed is at the end of the chain.
75 That conversion is always a cr_identity conversion. */
76
77typedef struct conversion conversion;
78struct conversion {
79 /* The kind of conversion represented by this step. */
80 conversion_kind kind;
81 /* The rank of this conversion. */
82 conversion_rank rank;
83 BOOL_BITFIELD user_conv_p : 1;
84 BOOL_BITFIELD ellipsis_p : 1;
85 BOOL_BITFIELD this_p : 1;
86 BOOL_BITFIELD bad_p : 1;
87 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88 temporary should be created to hold the result of the
89 conversion. */
90 BOOL_BITFIELD need_temporary_p : 1;
91 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92 copy constructor must be accessible, even though it is not being
93 used. */
94 BOOL_BITFIELD check_copy_constructor_p : 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p : 1;
98 /* The type of the expression resulting from the conversion. */
99 tree type;
100 union {
101 /* The next conversion in the chain. Since the conversions are
102 arranged from outermost to innermost, the NEXT conversion will
103 actually be performed before this conversion. This variant is
104 used only when KIND is neither ck_identity nor ck_ambig. */
105 conversion *next;
106 /* The expression at the beginning of the conversion chain. This
107 variant is used only if KIND is ck_identity or ck_ambig. */
108 tree expr;
109 } u;
110 /* The function candidate corresponding to this conversion
111 sequence. This field is only used if KIND is ck_user. */
112 struct z_candidate *cand;
113};
114
115#define CONVERSION_RANK(NODE) \
116 ((NODE)->bad_p ? cr_bad \
117 : (NODE)->ellipsis_p ? cr_ellipsis \
118 : (NODE)->user_conv_p ? cr_user \
119 : (NODE)->rank)
120
121static struct obstack conversion_obstack;
122static bool conversion_obstack_initialized;
123
124static struct z_candidate * tourney (struct z_candidate *);
125static int equal_functions (tree, tree);
126static int joust (struct z_candidate *, struct z_candidate *, bool);
127static int compare_ics (conversion *, conversion *);
128static tree build_over_call (struct z_candidate *, int);
129static tree build_java_interface_fn_ref (tree, tree);
130#define convert_like(CONV, EXPR) \
131 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
132 /*issue_conversion_warnings=*/true, \
133 /*c_cast_p=*/false)
134#define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
135 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
136 /*issue_conversion_warnings=*/true, \
137 /*c_cast_p=*/false)
138static tree convert_like_real (conversion *, tree, tree, int, int, bool,
139 bool);
140static void op_error (enum tree_code, enum tree_code, tree, tree,
141 tree, const char *);
142static tree build_object_call (tree, tree);
143static tree resolve_args (tree);
144static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
145static void print_z_candidate (const char *, struct z_candidate *);
146static void print_z_candidates (struct z_candidate *);
147static tree build_this (tree);
148static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
149static bool any_strictly_viable (struct z_candidate *);
150static struct z_candidate *add_template_candidate
151 (struct z_candidate **, tree, tree, tree, tree, tree,
152 tree, tree, int, unification_kind_t);
153static struct z_candidate *add_template_candidate_real
154 (struct z_candidate **, tree, tree, tree, tree, tree,
155 tree, tree, int, tree, unification_kind_t);
156static struct z_candidate *add_template_conv_candidate
157 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
158static void add_builtin_candidates
159 (struct z_candidate **, enum tree_code, enum tree_code,
160 tree, tree *, int);
161static void add_builtin_candidate
162 (struct z_candidate **, enum tree_code, enum tree_code,
163 tree, tree, tree, tree *, tree *, int);
164static bool is_complete (tree);
165static void build_builtin_candidate
166 (struct z_candidate **, tree, tree, tree, tree *, tree *,
167 int);
168static struct z_candidate *add_conv_candidate
169 (struct z_candidate **, tree, tree, tree, tree, tree);
170static struct z_candidate *add_function_candidate
171 (struct z_candidate **, tree, tree, tree, tree, tree, int);
172static conversion *implicit_conversion (tree, tree, tree, bool, int);
173static conversion *standard_conversion (tree, tree, tree, bool, int);
174static conversion *reference_binding (tree, tree, tree, bool, int);
175static conversion *build_conv (conversion_kind, tree, conversion *);
176static bool is_subseq (conversion *, conversion *);
177static tree maybe_handle_ref_bind (conversion **);
178static void maybe_handle_implicit_object (conversion **);
179static struct z_candidate *add_candidate
180 (struct z_candidate **, tree, tree, size_t,
181 conversion **, tree, tree, int);
182static tree source_type (conversion *);
183static void add_warning (struct z_candidate *, struct z_candidate *);
184static bool reference_related_p (tree, tree);
185static bool reference_compatible_p (tree, tree);
186static conversion *convert_class_to_reference (tree, tree, tree);
187static conversion *direct_reference_binding (tree, conversion *);
188static bool promoted_arithmetic_type_p (tree);
189static conversion *conditional_conversion (tree, tree);
190static char *name_as_c_string (tree, tree, bool *);
191static tree call_builtin_trap (void);
192static tree prep_operand (tree);
193static void add_candidates (tree, tree, tree, bool, tree, tree,
194 int, struct z_candidate **);
195static conversion *merge_conversion_sequences (conversion *, conversion *);
196static bool magic_varargs_p (tree);
197typedef void (*diagnostic_fn_t) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
198static tree build_temp (tree, tree, int, diagnostic_fn_t *);
199static void check_constructor_callable (tree, tree);
200
201/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
202 NAME can take many forms... */
203
204bool
205check_dtor_name (tree basetype, tree name)
206{
207 /* Just accept something we've already complained about. */
208 if (name == error_mark_node)
209 return true;
210
211 if (TREE_CODE (name) == TYPE_DECL)
212 name = TREE_TYPE (name);
213 else if (TYPE_P (name))
214 /* OK */;
215 else if (TREE_CODE (name) == IDENTIFIER_NODE)
216 {
217 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
218 || (TREE_CODE (basetype) == ENUMERAL_TYPE
219 && name == TYPE_IDENTIFIER (basetype)))
220 return true;
221 else
222 name = get_type_value (name);
223 }
224 else
225 {
226 /* In the case of:
227
228 template <class T> struct S { ~S(); };
229 int i;
230 i.~S();
231
232 NAME will be a class template. */
233 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
234 return false;
235 }
236
237 if (!name)
238 return false;
239 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
240}
241
242/* We want the address of a function or method. We avoid creating a
243 pointer-to-member function. */
244
245tree
246build_addr_func (tree function)
247{
248 tree type = TREE_TYPE (function);
249
250 /* We have to do these by hand to avoid real pointer to member
251 functions. */
252 if (TREE_CODE (type) == METHOD_TYPE)
253 {
254 if (TREE_CODE (function) == OFFSET_REF)
255 {
256 tree object = build_address (TREE_OPERAND (function, 0));
257 return get_member_function_from_ptrfunc (&object,
258 TREE_OPERAND (function, 1));
259 }
260 function = build_address (function);
261 }
262 else
263 function = decay_conversion (function);
264
265 return function;
266}
267
268/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
269 POINTER_TYPE to those. Note, pointer to member function types
270 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
271
272tree
273build_call (tree function, tree parms)
274{
275 int is_constructor = 0;
276 int nothrow;
277 tree tmp;
278 tree decl;
279 tree result_type;
280 tree fntype;
281
282 function = build_addr_func (function);
283
284 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
285 fntype = TREE_TYPE (TREE_TYPE (function));
286 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
287 || TREE_CODE (fntype) == METHOD_TYPE);
288 result_type = TREE_TYPE (fntype);
289
290 if (TREE_CODE (function) == ADDR_EXPR
291 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
292 {
293 decl = TREE_OPERAND (function, 0);
294 if (!TREE_USED (decl))
295 {
296 /* We invoke build_call directly for several library
297 functions. These may have been declared normally if
298 we're building libgcc, so we can't just check
299 DECL_ARTIFICIAL. */
300 gcc_assert (DECL_ARTIFICIAL (decl)
301 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
302 "__", 2));
303 mark_used (decl);
304 }
305 }
306 else
307 decl = NULL_TREE;
308
309 /* We check both the decl and the type; a function may be known not to
310 throw without being declared throw(). */
311 nothrow = ((decl && TREE_NOTHROW (decl))
312 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
313
314 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
315 current_function_returns_abnormally = 1;
316
317 if (decl && TREE_DEPRECATED (decl))
318 warn_deprecated_use (decl);
319 require_complete_eh_spec_types (fntype, decl);
320
321 if (decl && DECL_CONSTRUCTOR_P (decl))
322 is_constructor = 1;
323
324 /* Don't pass empty class objects by value. This is useful
325 for tags in STL, which are used to control overload resolution.
326 We don't need to handle other cases of copying empty classes. */
327 if (! decl || ! DECL_BUILT_IN (decl))
328 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
329 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
330 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
331 {
332 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
333 TREE_VALUE (tmp) = build2 (COMPOUND_EXPR, TREE_TYPE (t),
334 TREE_VALUE (tmp), t);
335 }
336
337 function = build3 (CALL_EXPR, result_type, function, parms, NULL_TREE);
338 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
339 TREE_NOTHROW (function) = nothrow;
340
341 return function;
342}
343
344/* Build something of the form ptr->method (args)
345 or object.method (args). This can also build
346 calls to constructors, and find friends.
347
348 Member functions always take their class variable
349 as a pointer.
350
351 INSTANCE is a class instance.
352
353 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
354
355 PARMS help to figure out what that NAME really refers to.
356
357 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
358 down to the real instance type to use for access checking. We need this
359 information to get protected accesses correct.
360
361 FLAGS is the logical disjunction of zero or more LOOKUP_
362 flags. See cp-tree.h for more info.
363
364 If this is all OK, calls build_function_call with the resolved
365 member function.
366
367 This function must also handle being called to perform
368 initialization, promotion/coercion of arguments, and
369 instantiation of default parameters.
370
371 Note that NAME may refer to an instance variable name. If
372 `operator()()' is defined for the type of that field, then we return
373 that result. */
374
375/* New overloading code. */
376
377typedef struct z_candidate z_candidate;
378
379typedef struct candidate_warning candidate_warning;
380struct candidate_warning {
381 z_candidate *loser;
382 candidate_warning *next;
383};
384
385struct z_candidate {
386 /* The FUNCTION_DECL that will be called if this candidate is
387 selected by overload resolution. */
388 tree fn;
389 /* The arguments to use when calling this function. */
390 tree args;
391 /* The implicit conversion sequences for each of the arguments to
392 FN. */
393 conversion **convs;
394 /* The number of implicit conversion sequences. */
395 size_t num_convs;
396 /* If FN is a user-defined conversion, the standard conversion
397 sequence from the type returned by FN to the desired destination
398 type. */
399 conversion *second_conv;
400 int viable;
401 /* If FN is a member function, the binfo indicating the path used to
402 qualify the name of FN at the call site. This path is used to
403 determine whether or not FN is accessible if it is selected by
404 overload resolution. The DECL_CONTEXT of FN will always be a
405 (possibly improper) base of this binfo. */
406 tree access_path;
407 /* If FN is a non-static member function, the binfo indicating the
408 subobject to which the `this' pointer should be converted if FN
409 is selected by overload resolution. The type pointed to the by
410 the `this' pointer must correspond to the most derived class
411 indicated by the CONVERSION_PATH. */
412 tree conversion_path;
413 tree template_decl;
414 candidate_warning *warnings;
415 z_candidate *next;
416};
417
418/* Returns true iff T is a null pointer constant in the sense of
419 [conv.ptr]. */
420
421bool
422null_ptr_cst_p (tree t)
423{
424 /* [conv.ptr]
425
426 A null pointer constant is an integral constant expression
427 (_expr.const_) rvalue of integer type that evaluates to zero. */
428 t = integral_constant_value (t);
429 if (t == null_node)
430 return true;
431 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
432 {
433 STRIP_NOPS (t);
434 if (!TREE_CONSTANT_OVERFLOW (t))
435 return true;
436 }
437 return false;
438}
439
440/* Returns nonzero if PARMLIST consists of only default parms and/or
441 ellipsis. */
442
443bool
444sufficient_parms_p (tree parmlist)
445{
446 for (; parmlist && parmlist != void_list_node;
447 parmlist = TREE_CHAIN (parmlist))
448 if (!TREE_PURPOSE (parmlist))
449 return false;
450 return true;
451}
452
453/* Allocate N bytes of memory from the conversion obstack. The memory
454 is zeroed before being returned. */
455
456static void *
457conversion_obstack_alloc (size_t n)
458{
459 void *p;
460 if (!conversion_obstack_initialized)
461 {
462 gcc_obstack_init (&conversion_obstack);
463 conversion_obstack_initialized = true;
464 }
465 p = obstack_alloc (&conversion_obstack, n);
466 memset (p, 0, n);
467 return p;
468}
469
470/* Dynamically allocate a conversion. */
471
472static conversion *
473alloc_conversion (conversion_kind kind)
474{
475 conversion *c;
476 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
477 c->kind = kind;
478 return c;
479}
480
481#ifdef ENABLE_CHECKING
482
483/* Make sure that all memory on the conversion obstack has been
484 freed. */
485
486void
487validate_conversion_obstack (void)
488{
489 if (conversion_obstack_initialized)
490 gcc_assert ((obstack_next_free (&conversion_obstack)
491 == obstack_base (&conversion_obstack)));
492}
493
494#endif /* ENABLE_CHECKING */
495
496/* Dynamically allocate an array of N conversions. */
497
498static conversion **
499alloc_conversions (size_t n)
500{
501 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
502}
503
504static conversion *
505build_conv (conversion_kind code, tree type, conversion *from)
506{
507 conversion *t;
508 conversion_rank rank = CONVERSION_RANK (from);
509
510 /* We can't use buildl1 here because CODE could be USER_CONV, which
511 takes two arguments. In that case, the caller is responsible for
512 filling in the second argument. */
513 t = alloc_conversion (code);
514 t->type = type;
515 t->u.next = from;
516
517 switch (code)
518 {
519 case ck_ptr:
520 case ck_pmem:
521 case ck_base:
522 case ck_std:
523 if (rank < cr_std)
524 rank = cr_std;
525 break;
526
527 case ck_qual:
528 if (rank < cr_exact)
529 rank = cr_exact;
530 break;
531
532 default:
533 break;
534 }
535 t->rank = rank;
536 t->user_conv_p = (code == ck_user || from->user_conv_p);
537 t->bad_p = from->bad_p;
538 t->base_p = false;
539 return t;
540}
541
542/* Build a representation of the identity conversion from EXPR to
543 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
544
545static conversion *
546build_identity_conv (tree type, tree expr)
547{
548 conversion *c;
549
550 c = alloc_conversion (ck_identity);
551 c->type = type;
552 c->u.expr = expr;
553
554 return c;
555}
556
557/* Converting from EXPR to TYPE was ambiguous in the sense that there
558 were multiple user-defined conversions to accomplish the job.
559 Build a conversion that indicates that ambiguity. */
560
561static conversion *
562build_ambiguous_conv (tree type, tree expr)
563{
564 conversion *c;
565
566 c = alloc_conversion (ck_ambig);
567 c->type = type;
568 c->u.expr = expr;
569
570 return c;
571}
572
573tree
574strip_top_quals (tree t)
575{
576 if (TREE_CODE (t) == ARRAY_TYPE)
577 return t;
578 return cp_build_qualified_type (t, 0);
579}
580
581/* Returns the standard conversion path (see [conv]) from type FROM to type
582 TO, if any. For proper handling of null pointer constants, you must
583 also pass the expression EXPR to convert from. If C_CAST_P is true,
584 this conversion is coming from a C-style cast. */
585
586static conversion *
587standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
588 int flags)
589{
590 enum tree_code fcode, tcode;
591 conversion *conv;
592 bool fromref = false;
593
594 to = non_reference (to);
595 if (TREE_CODE (from) == REFERENCE_TYPE)
596 {
597 fromref = true;
598 from = TREE_TYPE (from);
599 }
600 to = strip_top_quals (to);
601 from = strip_top_quals (from);
602
603 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
604 && expr && type_unknown_p (expr))
605 {
606 expr = instantiate_type (to, expr, tf_conv);
607 if (expr == error_mark_node)
608 return NULL;
609 from = TREE_TYPE (expr);
610 }
611
612 fcode = TREE_CODE (from);
613 tcode = TREE_CODE (to);
614
615 conv = build_identity_conv (from, expr);
616 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
617 {
618 from = type_decays_to (from);
619 fcode = TREE_CODE (from);
620 conv = build_conv (ck_lvalue, from, conv);
621 }
622 else if (fromref || (expr && lvalue_p (expr)))
623 {
624 if (expr)
625 {
626 tree bitfield_type;
627 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
628 if (bitfield_type)
629 {
630 from = strip_top_quals (bitfield_type);
631 fcode = TREE_CODE (from);
632 }
633 }
634 conv = build_conv (ck_rvalue, from, conv);
635 }
636
637 /* Allow conversion between `__complex__' data types. */
638 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
639 {
640 /* The standard conversion sequence to convert FROM to TO is
641 the standard conversion sequence to perform componentwise
642 conversion. */
643 conversion *part_conv = standard_conversion
644 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
645
646 if (part_conv)
647 {
648 conv = build_conv (part_conv->kind, to, conv);
649 conv->rank = part_conv->rank;
650 }
651 else
652 conv = NULL;
653
654 return conv;
655 }
656
657 if (same_type_p (from, to))
658 return conv;
659
660 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
661 && expr && null_ptr_cst_p (expr))
662 conv = build_conv (ck_std, to, conv);
663 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
664 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
665 {
666 /* For backwards brain damage compatibility, allow interconversion of
667 pointers and integers with a pedwarn. */
668 conv = build_conv (ck_std, to, conv);
669 conv->bad_p = true;
670 }
671 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
672 {
673 /* For backwards brain damage compatibility, allow interconversion of
674 enums and integers with a pedwarn. */
675 conv = build_conv (ck_std, to, conv);
676 conv->bad_p = true;
677 }
678 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
679 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
680 {
681 tree to_pointee;
682 tree from_pointee;
683
684 if (tcode == POINTER_TYPE
685 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
686 TREE_TYPE (to)))
687 ;
688 else if (VOID_TYPE_P (TREE_TYPE (to))
689 && !TYPE_PTRMEM_P (from)
690 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
691 {
692 from = build_pointer_type
693 (cp_build_qualified_type (void_type_node,
694 cp_type_quals (TREE_TYPE (from))));
695 conv = build_conv (ck_ptr, from, conv);
696 }
697 else if (TYPE_PTRMEM_P (from))
698 {
699 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
700 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
701
702 if (DERIVED_FROM_P (fbase, tbase)
703 && (same_type_ignoring_top_level_qualifiers_p
704 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
705 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
706 {
707 from = build_ptrmem_type (tbase,
708 TYPE_PTRMEM_POINTED_TO_TYPE (from));
709 conv = build_conv (ck_pmem, from, conv);
710 }
711 else if (!same_type_p (fbase, tbase))
712 return NULL;
713 }
714 else if (IS_AGGR_TYPE (TREE_TYPE (from))
715 && IS_AGGR_TYPE (TREE_TYPE (to))
716 /* [conv.ptr]
717
718 An rvalue of type "pointer to cv D," where D is a
719 class type, can be converted to an rvalue of type
720 "pointer to cv B," where B is a base class (clause
721 _class.derived_) of D. If B is an inaccessible
722 (clause _class.access_) or ambiguous
723 (_class.member.lookup_) base class of D, a program
724 that necessitates this conversion is ill-formed.
725 Therefore, we use DERIVED_FROM_P, and do not check
726 access or uniqueness. */
727 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))
728 /* If FROM is not yet complete, then we must be parsing
729 the body of a class. We know what's derived from
730 what, but we can't actually perform a
731 derived-to-base conversion. For example, in:
732
733 struct D : public B {
734 static const int i = sizeof((B*)(D*)0);
735 };
736
737 the D*-to-B* conversion is a reinterpret_cast, not a
738 static_cast. */
739 && COMPLETE_TYPE_P (TREE_TYPE (from)))
740 {
741 from =
742 cp_build_qualified_type (TREE_TYPE (to),
743 cp_type_quals (TREE_TYPE (from)));
744 from = build_pointer_type (from);
745 conv = build_conv (ck_ptr, from, conv);
746 conv->base_p = true;
747 }
748
749 if (tcode == POINTER_TYPE)
750 {
751 to_pointee = TREE_TYPE (to);
752 from_pointee = TREE_TYPE (from);
753 }
754 else
755 {
756 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
757 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
758 }
759
760 if (same_type_p (from, to))
761 /* OK */;
762 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
763 /* In a C-style cast, we ignore CV-qualification because we
764 are allowed to perform a static_cast followed by a
765 const_cast. */
766 conv = build_conv (ck_qual, to, conv);
767 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
768 conv = build_conv (ck_qual, to, conv);
769 else if (expr && string_conv_p (to, expr, 0))
770 /* converting from string constant to char *. */
771 conv = build_conv (ck_qual, to, conv);
772 else if (ptr_reasonably_similar (to_pointee, from_pointee))
773 {
774 conv = build_conv (ck_ptr, to, conv);
775 conv->bad_p = true;
776 }
777 else
778 return NULL;
779
780 from = to;
781 }
782 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
783 {
784 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
785 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
786 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
787 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
788
789 if (!DERIVED_FROM_P (fbase, tbase)
790 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
791 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
792 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
793 || cp_type_quals (fbase) != cp_type_quals (tbase))
794 return NULL;
795
796 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
797 from = build_method_type_directly (from,
798 TREE_TYPE (fromfn),
799 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
800 from = build_ptrmemfunc_type (build_pointer_type (from));
801 conv = build_conv (ck_pmem, from, conv);
802 conv->base_p = true;
803 }
804 else if (tcode == BOOLEAN_TYPE)
805 {
806 /* [conv.bool]
807
808 An rvalue of arithmetic, enumeration, pointer, or pointer to
809 member type can be converted to an rvalue of type bool. */
810 if (ARITHMETIC_TYPE_P (from)
811 || fcode == ENUMERAL_TYPE
812 || fcode == POINTER_TYPE
813 || TYPE_PTR_TO_MEMBER_P (from))
814 {
815 conv = build_conv (ck_std, to, conv);
816 if (fcode == POINTER_TYPE
817 || TYPE_PTRMEM_P (from)
818 || (TYPE_PTRMEMFUNC_P (from)
819 && conv->rank < cr_pbool))
820 conv->rank = cr_pbool;
821 return conv;
822 }
823
824 return NULL;
825 }
826 /* We don't check for ENUMERAL_TYPE here because there are no standard
827 conversions to enum type. */
828 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
829 || tcode == REAL_TYPE)
830 {
831 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
832 return NULL;
833 conv = build_conv (ck_std, to, conv);
834
835 /* Give this a better rank if it's a promotion. */
836 if (same_type_p (to, type_promotes_to (from))
837 && conv->u.next->rank <= cr_promotion)
838 conv->rank = cr_promotion;
839 }
840 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
841 && vector_types_convertible_p (from, to))
842 return build_conv (ck_std, to, conv);
843 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
844 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
845 && is_properly_derived_from (from, to))
846 {
847 if (conv->kind == ck_rvalue)
848 conv = conv->u.next;
849 conv = build_conv (ck_base, to, conv);
850 /* The derived-to-base conversion indicates the initialization
851 of a parameter with base type from an object of a derived
852 type. A temporary object is created to hold the result of
853 the conversion. */
854 conv->need_temporary_p = true;
855 }
856 else
857 return NULL;
858
859 return conv;
860}
861
862/* Returns nonzero if T1 is reference-related to T2. */
863
864static bool
865reference_related_p (tree t1, tree t2)
866{
867 t1 = TYPE_MAIN_VARIANT (t1);
868 t2 = TYPE_MAIN_VARIANT (t2);
869
870 /* [dcl.init.ref]
871
872 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
873 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
874 of T2. */
875 return (same_type_p (t1, t2)
876 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
877 && DERIVED_FROM_P (t1, t2)));
878}
879
880/* Returns nonzero if T1 is reference-compatible with T2. */
881
882static bool
883reference_compatible_p (tree t1, tree t2)
884{
885 /* [dcl.init.ref]
886
887 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
888 reference-related to T2 and cv1 is the same cv-qualification as,
889 or greater cv-qualification than, cv2. */
890 return (reference_related_p (t1, t2)
891 && at_least_as_qualified_p (t1, t2));
892}
893
894/* Determine whether or not the EXPR (of class type S) can be
895 converted to T as in [over.match.ref]. */
896
897static conversion *
898convert_class_to_reference (tree t, tree s, tree expr)
899{
900 tree conversions;
901 tree arglist;
902 conversion *conv;
903 tree reference_type;
904 struct z_candidate *candidates;
905 struct z_candidate *cand;
906 bool any_viable_p;
907
908 conversions = lookup_conversions (s);
909 if (!conversions)
910 return NULL;
911
912 /* [over.match.ref]
913
914 Assuming that "cv1 T" is the underlying type of the reference
915 being initialized, and "cv S" is the type of the initializer
916 expression, with S a class type, the candidate functions are
917 selected as follows:
918
919 --The conversion functions of S and its base classes are
920 considered. Those that are not hidden within S and yield type
921 "reference to cv2 T2", where "cv1 T" is reference-compatible
922 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
923
924 The argument list has one argument, which is the initializer
925 expression. */
926
927 candidates = 0;
928
929 /* Conceptually, we should take the address of EXPR and put it in
930 the argument list. Unfortunately, however, that can result in
931 error messages, which we should not issue now because we are just
932 trying to find a conversion operator. Therefore, we use NULL,
933 cast to the appropriate type. */
934 arglist = build_int_cst (build_pointer_type (s), 0);
935 arglist = build_tree_list (NULL_TREE, arglist);
936
937 reference_type = build_reference_type (t);
938
939 while (conversions)
940 {
941 tree fns = TREE_VALUE (conversions);
942
943 for (; fns; fns = OVL_NEXT (fns))
944 {
945 tree f = OVL_CURRENT (fns);
946 tree t2 = TREE_TYPE (TREE_TYPE (f));
947
948 cand = NULL;
949
950 /* If this is a template function, try to get an exact
951 match. */
952 if (TREE_CODE (f) == TEMPLATE_DECL)
953 {
954 cand = add_template_candidate (&candidates,
955 f, s,
956 NULL_TREE,
957 arglist,
958 reference_type,
959 TYPE_BINFO (s),
960 TREE_PURPOSE (conversions),
961 LOOKUP_NORMAL,
962 DEDUCE_CONV);
963
964 if (cand)
965 {
966 /* Now, see if the conversion function really returns
967 an lvalue of the appropriate type. From the
968 point of view of unification, simply returning an
969 rvalue of the right type is good enough. */
970 f = cand->fn;
971 t2 = TREE_TYPE (TREE_TYPE (f));
972 if (TREE_CODE (t2) != REFERENCE_TYPE
973 || !reference_compatible_p (t, TREE_TYPE (t2)))
974 {
975 candidates = candidates->next;
976 cand = NULL;
977 }
978 }
979 }
980 else if (TREE_CODE (t2) == REFERENCE_TYPE
981 && reference_compatible_p (t, TREE_TYPE (t2)))
982 cand = add_function_candidate (&candidates, f, s, arglist,
983 TYPE_BINFO (s),
984 TREE_PURPOSE (conversions),
985 LOOKUP_NORMAL);
986
987 if (cand)
988 {
989 conversion *identity_conv;
990 /* Build a standard conversion sequence indicating the
991 binding from the reference type returned by the
992 function to the desired REFERENCE_TYPE. */
993 identity_conv
994 = build_identity_conv (TREE_TYPE (TREE_TYPE
995 (TREE_TYPE (cand->fn))),
996 NULL_TREE);
997 cand->second_conv
998 = (direct_reference_binding
999 (reference_type, identity_conv));
1000 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1001 }
1002 }
1003 conversions = TREE_CHAIN (conversions);
1004 }
1005
1006 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1007 /* If none of the conversion functions worked out, let our caller
1008 know. */
1009 if (!any_viable_p)
1010 return NULL;
1011
1012 cand = tourney (candidates);
1013 if (!cand)
1014 return NULL;
1015
1016 /* Now that we know that this is the function we're going to use fix
1017 the dummy first argument. */
1018 cand->args = tree_cons (NULL_TREE,
1019 build_this (expr),
1020 TREE_CHAIN (cand->args));
1021
1022 /* Build a user-defined conversion sequence representing the
1023 conversion. */
1024 conv = build_conv (ck_user,
1025 TREE_TYPE (TREE_TYPE (cand->fn)),
1026 build_identity_conv (TREE_TYPE (expr), expr));
1027 conv->cand = cand;
1028
1029 /* Merge it with the standard conversion sequence from the
1030 conversion function's return type to the desired type. */
1031 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1032
1033 if (cand->viable == -1)
1034 conv->bad_p = true;
1035
1036 return cand->second_conv;
1037}
1038
1039/* A reference of the indicated TYPE is being bound directly to the
1040 expression represented by the implicit conversion sequence CONV.
1041 Return a conversion sequence for this binding. */
1042
1043static conversion *
1044direct_reference_binding (tree type, conversion *conv)
1045{
1046 tree t;
1047
1048 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1049 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1050
1051 t = TREE_TYPE (type);
1052
1053 /* [over.ics.rank]
1054
1055 When a parameter of reference type binds directly
1056 (_dcl.init.ref_) to an argument expression, the implicit
1057 conversion sequence is the identity conversion, unless the
1058 argument expression has a type that is a derived class of the
1059 parameter type, in which case the implicit conversion sequence is
1060 a derived-to-base Conversion.
1061
1062 If the parameter binds directly to the result of applying a
1063 conversion function to the argument expression, the implicit
1064 conversion sequence is a user-defined conversion sequence
1065 (_over.ics.user_), with the second standard conversion sequence
1066 either an identity conversion or, if the conversion function
1067 returns an entity of a type that is a derived class of the
1068 parameter type, a derived-to-base conversion. */
1069 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1070 {
1071 /* Represent the derived-to-base conversion. */
1072 conv = build_conv (ck_base, t, conv);
1073 /* We will actually be binding to the base-class subobject in
1074 the derived class, so we mark this conversion appropriately.
1075 That way, convert_like knows not to generate a temporary. */
1076 conv->need_temporary_p = false;
1077 }
1078 return build_conv (ck_ref_bind, type, conv);
1079}
1080
1081/* Returns the conversion path from type FROM to reference type TO for
1082 purposes of reference binding. For lvalue binding, either pass a
1083 reference type to FROM or an lvalue expression to EXPR. If the
1084 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1085 the conversion returned. If C_CAST_P is true, this
1086 conversion is coming from a C-style cast. */
1087
1088static conversion *
1089reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1090{
1091 conversion *conv = NULL;
1092 tree to = TREE_TYPE (rto);
1093 tree from = rfrom;
1094 bool related_p;
1095 bool compatible_p;
1096 cp_lvalue_kind lvalue_p = clk_none;
1097
1098 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1099 {
1100 expr = instantiate_type (to, expr, tf_none);
1101 if (expr == error_mark_node)
1102 return NULL;
1103 from = TREE_TYPE (expr);
1104 }
1105
1106 if (TREE_CODE (from) == REFERENCE_TYPE)
1107 {
1108 /* Anything with reference type is an lvalue. */
1109 lvalue_p = clk_ordinary;
1110 from = TREE_TYPE (from);
1111 }
1112 else if (expr)
1113 lvalue_p = real_lvalue_p (expr);
1114
1115 /* Figure out whether or not the types are reference-related and
1116 reference compatible. We have do do this after stripping
1117 references from FROM. */
1118 related_p = reference_related_p (to, from);
1119 /* If this is a C cast, first convert to an appropriately qualified
1120 type, so that we can later do a const_cast to the desired type. */
1121 if (related_p && c_cast_p
1122 && !at_least_as_qualified_p (to, from))
1123 to = build_qualified_type (to, cp_type_quals (from));
1124 compatible_p = reference_compatible_p (to, from);
1125
1126 if (lvalue_p && compatible_p)
1127 {
1128 /* [dcl.init.ref]
1129
1130 If the initializer expression
1131
1132 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1133 is reference-compatible with "cv2 T2,"
1134
1135 the reference is bound directly to the initializer expression
1136 lvalue. */
1137 conv = build_identity_conv (from, expr);
1138 conv = direct_reference_binding (rto, conv);
1139 if ((lvalue_p & clk_bitfield) != 0
1140 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1141 /* For the purposes of overload resolution, we ignore the fact
1142 this expression is a bitfield or packed field. (In particular,
1143 [over.ics.ref] says specifically that a function with a
1144 non-const reference parameter is viable even if the
1145 argument is a bitfield.)
1146
1147 However, when we actually call the function we must create
1148 a temporary to which to bind the reference. If the
1149 reference is volatile, or isn't const, then we cannot make
1150 a temporary, so we just issue an error when the conversion
1151 actually occurs. */
1152 conv->need_temporary_p = true;
1153
1154 return conv;
1155 }
1156 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1157 {
1158 /* [dcl.init.ref]
1159
1160 If the initializer expression
1161
1162 -- has a class type (i.e., T2 is a class type) can be
1163 implicitly converted to an lvalue of type "cv3 T3," where
1164 "cv1 T1" is reference-compatible with "cv3 T3". (this
1165 conversion is selected by enumerating the applicable
1166 conversion functions (_over.match.ref_) and choosing the
1167 best one through overload resolution. (_over.match_).
1168
1169 the reference is bound to the lvalue result of the conversion
1170 in the second case. */
1171 conv = convert_class_to_reference (to, from, expr);
1172 if (conv)
1173 return conv;
1174 }
1175
1176 /* From this point on, we conceptually need temporaries, even if we
1177 elide them. Only the cases above are "direct bindings". */
1178 if (flags & LOOKUP_NO_TEMP_BIND)
1179 return NULL;
1180
1181 /* [over.ics.rank]
1182
1183 When a parameter of reference type is not bound directly to an
1184 argument expression, the conversion sequence is the one required
1185 to convert the argument expression to the underlying type of the
1186 reference according to _over.best.ics_. Conceptually, this
1187 conversion sequence corresponds to copy-initializing a temporary
1188 of the underlying type with the argument expression. Any
1189 difference in top-level cv-qualification is subsumed by the
1190 initialization itself and does not constitute a conversion. */
1191
1192 /* [dcl.init.ref]
1193
1194 Otherwise, the reference shall be to a non-volatile const type. */
1195 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1196 return NULL;
1197
1198 /* [dcl.init.ref]
1199
1200 If the initializer expression is an rvalue, with T2 a class type,
1201 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1202 is bound in one of the following ways:
1203
1204 -- The reference is bound to the object represented by the rvalue
1205 or to a sub-object within that object.
1206
1207 -- ...
1208
1209 We use the first alternative. The implicit conversion sequence
1210 is supposed to be same as we would obtain by generating a
1211 temporary. Fortunately, if the types are reference compatible,
1212 then this is either an identity conversion or the derived-to-base
1213 conversion, just as for direct binding. */
1214 if (CLASS_TYPE_P (from) && compatible_p)
1215 {
1216 conv = build_identity_conv (from, expr);
1217 conv = direct_reference_binding (rto, conv);
1218 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1219 conv->u.next->check_copy_constructor_p = true;
1220 return conv;
1221 }
1222
1223 /* [dcl.init.ref]
1224
1225 Otherwise, a temporary of type "cv1 T1" is created and
1226 initialized from the initializer expression using the rules for a
1227 non-reference copy initialization. If T1 is reference-related to
1228 T2, cv1 must be the same cv-qualification as, or greater
1229 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1230 if (related_p && !at_least_as_qualified_p (to, from))
1231 return NULL;
1232
1233 conv = implicit_conversion (to, from, expr, c_cast_p,
1234 flags);
1235 if (!conv)
1236 return NULL;
1237
1238 conv = build_conv (ck_ref_bind, rto, conv);
1239 /* This reference binding, unlike those above, requires the
1240 creation of a temporary. */
1241 conv->need_temporary_p = true;
1242
1243 return conv;
1244}
1245
1246/* Returns the implicit conversion sequence (see [over.ics]) from type
1247 FROM to type TO. The optional expression EXPR may affect the
1248 conversion. FLAGS are the usual overloading flags. Only
1249 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1250 conversion is coming from a C-style cast. */
1251
1252static conversion *
1253implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1254 int flags)
1255{
1256 conversion *conv;
1257
1258 if (from == error_mark_node || to == error_mark_node
1259 || expr == error_mark_node)
1260 return NULL;
1261
1262 if (TREE_CODE (to) == REFERENCE_TYPE)
1263 conv = reference_binding (to, from, expr, c_cast_p, flags);
1264 else
1265 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1266
1267 if (conv)
1268 return conv;
1269
1270 if (expr != NULL_TREE
1271 && (IS_AGGR_TYPE (from)
1272 || IS_AGGR_TYPE (to))
1273 && (flags & LOOKUP_NO_CONVERSION) == 0)
1274 {
1275 struct z_candidate *cand;
1276
1277 cand = build_user_type_conversion_1
1278 (to, expr, LOOKUP_ONLYCONVERTING);
1279 if (cand)
1280 conv = cand->second_conv;
1281
1282 /* We used to try to bind a reference to a temporary here, but that
1283 is now handled by the recursive call to this function at the end
1284 of reference_binding. */
1285 return conv;
1286 }
1287
1288 return NULL;
1289}
1290
1291/* Add a new entry to the list of candidates. Used by the add_*_candidate
1292 functions. */
1293
1294static struct z_candidate *
1295add_candidate (struct z_candidate **candidates,
1296 tree fn, tree args,
1297 size_t num_convs, conversion **convs,
1298 tree access_path, tree conversion_path,
1299 int viable)
1300{
1301 struct z_candidate *cand = (struct z_candidate *)
1302 conversion_obstack_alloc (sizeof (struct z_candidate));
1303
1304 cand->fn = fn;
1305 cand->args = args;
1306 cand->convs = convs;
1307 cand->num_convs = num_convs;
1308 cand->access_path = access_path;
1309 cand->conversion_path = conversion_path;
1310 cand->viable = viable;
1311 cand->next = *candidates;
1312 *candidates = cand;
1313
1314 return cand;
1315}
1316
1317/* Create an overload candidate for the function or method FN called with
1318 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1319 to implicit_conversion.
1320
1321 CTYPE, if non-NULL, is the type we want to pretend this function
1322 comes from for purposes of overload resolution. */
1323
1324static struct z_candidate *
1325add_function_candidate (struct z_candidate **candidates,
1326 tree fn, tree ctype, tree arglist,
1327 tree access_path, tree conversion_path,
1328 int flags)
1329{
1330 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1331 int i, len;
1332 conversion **convs;
1333 tree parmnode, argnode;
1334 tree orig_arglist;
1335 int viable = 1;
1336
1337 /* At this point we should not see any functions which haven't been
1338 explicitly declared, except for friend functions which will have
1339 been found using argument dependent lookup. */
1340 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1341
1342 /* The `this', `in_chrg' and VTT arguments to constructors are not
1343 considered in overload resolution. */
1344 if (DECL_CONSTRUCTOR_P (fn))
1345 {
1346 parmlist = skip_artificial_parms_for (fn, parmlist);
1347 orig_arglist = arglist;
1348 arglist = skip_artificial_parms_for (fn, arglist);
1349 }
1350 else
1351 orig_arglist = arglist;
1352
1353 len = list_length (arglist);
1354 convs = alloc_conversions (len);
1355
1356 /* 13.3.2 - Viable functions [over.match.viable]
1357 First, to be a viable function, a candidate function shall have enough
1358 parameters to agree in number with the arguments in the list.
1359
1360 We need to check this first; otherwise, checking the ICSes might cause
1361 us to produce an ill-formed template instantiation. */
1362
1363 parmnode = parmlist;
1364 for (i = 0; i < len; ++i)
1365 {
1366 if (parmnode == NULL_TREE || parmnode == void_list_node)
1367 break;
1368 parmnode = TREE_CHAIN (parmnode);
1369 }
1370
1371 if (i < len && parmnode)
1372 viable = 0;
1373
1374 /* Make sure there are default args for the rest of the parms. */
1375 else if (!sufficient_parms_p (parmnode))
1376 viable = 0;
1377
1378 if (! viable)
1379 goto out;
1380
1381 /* Second, for F to be a viable function, there shall exist for each
1382 argument an implicit conversion sequence that converts that argument
1383 to the corresponding parameter of F. */
1384
1385 parmnode = parmlist;
1386 argnode = arglist;
1387
1388 for (i = 0; i < len; ++i)
1389 {
1390 tree arg = TREE_VALUE (argnode);
1391 tree argtype = lvalue_type (arg);
1392 conversion *t;
1393 int is_this;
1394
1395 if (parmnode == void_list_node)
1396 break;
1397
1398 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1399 && ! DECL_CONSTRUCTOR_P (fn));
1400
1401 if (parmnode)
1402 {
1403 tree parmtype = TREE_VALUE (parmnode);
1404
1405 /* The type of the implicit object parameter ('this') for
1406 overload resolution is not always the same as for the
1407 function itself; conversion functions are considered to
1408 be members of the class being converted, and functions
1409 introduced by a using-declaration are considered to be
1410 members of the class that uses them.
1411
1412 Since build_over_call ignores the ICS for the `this'
1413 parameter, we can just change the parm type. */
1414 if (ctype && is_this)
1415 {
1416 parmtype
1417 = build_qualified_type (ctype,
1418 TYPE_QUALS (TREE_TYPE (parmtype)));
1419 parmtype = build_pointer_type (parmtype);
1420 }
1421
1422 t = implicit_conversion (parmtype, argtype, arg,
1423 /*c_cast_p=*/false, flags);
1424 }
1425 else
1426 {
1427 t = build_identity_conv (argtype, arg);
1428 t->ellipsis_p = true;
1429 }
1430
1431 if (t && is_this)
1432 t->this_p = true;
1433
1434 convs[i] = t;
1435 if (! t)
1436 {
1437 viable = 0;
1438 break;
1439 }
1440
1441 if (t->bad_p)
1442 viable = -1;
1443
1444 if (parmnode)
1445 parmnode = TREE_CHAIN (parmnode);
1446 argnode = TREE_CHAIN (argnode);
1447 }
1448
1449 out:
1450 return add_candidate (candidates, fn, orig_arglist, len, convs,
1451 access_path, conversion_path, viable);
1452}
1453
1454/* Create an overload candidate for the conversion function FN which will
1455 be invoked for expression OBJ, producing a pointer-to-function which
1456 will in turn be called with the argument list ARGLIST, and add it to
1457 CANDIDATES. FLAGS is passed on to implicit_conversion.
1458
1459 Actually, we don't really care about FN; we care about the type it
1460 converts to. There may be multiple conversion functions that will
1461 convert to that type, and we rely on build_user_type_conversion_1 to
1462 choose the best one; so when we create our candidate, we record the type
1463 instead of the function. */
1464
1465static struct z_candidate *
1466add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1467 tree arglist, tree access_path, tree conversion_path)
1468{
1469 tree totype = TREE_TYPE (TREE_TYPE (fn));
1470 int i, len, viable, flags;
1471 tree parmlist, parmnode, argnode;
1472 conversion **convs;
1473
1474 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1475 parmlist = TREE_TYPE (parmlist);
1476 parmlist = TYPE_ARG_TYPES (parmlist);
1477
1478 len = list_length (arglist) + 1;
1479 convs = alloc_conversions (len);
1480 parmnode = parmlist;
1481 argnode = arglist;
1482 viable = 1;
1483 flags = LOOKUP_NORMAL;
1484
1485 /* Don't bother looking up the same type twice. */
1486 if (*candidates && (*candidates)->fn == totype)
1487 return NULL;
1488
1489 for (i = 0; i < len; ++i)
1490 {
1491 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1492 tree argtype = lvalue_type (arg);
1493 conversion *t;
1494
1495 if (i == 0)
1496 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1497 flags);
1498 else if (parmnode == void_list_node)
1499 break;
1500 else if (parmnode)
1501 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1502 /*c_cast_p=*/false, flags);
1503 else
1504 {
1505 t = build_identity_conv (argtype, arg);
1506 t->ellipsis_p = true;
1507 }
1508
1509 convs[i] = t;
1510 if (! t)
1511 break;
1512
1513 if (t->bad_p)
1514 viable = -1;
1515
1516 if (i == 0)
1517 continue;
1518
1519 if (parmnode)
1520 parmnode = TREE_CHAIN (parmnode);
1521 argnode = TREE_CHAIN (argnode);
1522 }
1523
1524 if (i < len)
1525 viable = 0;
1526
1527 if (!sufficient_parms_p (parmnode))
1528 viable = 0;
1529
1530 return add_candidate (candidates, totype, arglist, len, convs,
1531 access_path, conversion_path, viable);
1532}
1533
1534static void
1535build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1536 tree type1, tree type2, tree *args, tree *argtypes,
1537 int flags)
1538{
1539 conversion *t;
1540 conversion **convs;
1541 size_t num_convs;
1542 int viable = 1, i;
1543 tree types[2];
1544
1545 types[0] = type1;
1546 types[1] = type2;
1547
1548 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1549 convs = alloc_conversions (num_convs);
1550
1551 for (i = 0; i < 2; ++i)
1552 {
1553 if (! args[i])
1554 break;
1555
1556 t = implicit_conversion (types[i], argtypes[i], args[i],
1557 /*c_cast_p=*/false, flags);
1558 if (! t)
1559 {
1560 viable = 0;
1561 /* We need something for printing the candidate. */
1562 t = build_identity_conv (types[i], NULL_TREE);
1563 }
1564 else if (t->bad_p)
1565 viable = 0;
1566 convs[i] = t;
1567 }
1568
1569 /* For COND_EXPR we rearranged the arguments; undo that now. */
1570 if (args[2])
1571 {
1572 convs[2] = convs[1];
1573 convs[1] = convs[0];
1574 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1575 /*c_cast_p=*/false, flags);
1576 if (t)
1577 convs[0] = t;
1578 else
1579 viable = 0;
1580 }
1581
1582 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1583 num_convs, convs,
1584 /*access_path=*/NULL_TREE,
1585 /*conversion_path=*/NULL_TREE,
1586 viable);
1587}
1588
1589static bool
1590is_complete (tree t)
1591{
1592 return COMPLETE_TYPE_P (complete_type (t));
1593}
1594
1595/* Returns nonzero if TYPE is a promoted arithmetic type. */
1596
1597static bool
1598promoted_arithmetic_type_p (tree type)
1599{
1600 /* [over.built]
1601
1602 In this section, the term promoted integral type is used to refer
1603 to those integral types which are preserved by integral promotion
1604 (including e.g. int and long but excluding e.g. char).
1605 Similarly, the term promoted arithmetic type refers to promoted
1606 integral types plus floating types. */
1607 return ((INTEGRAL_TYPE_P (type)
1608 && same_type_p (type_promotes_to (type), type))
1609 || TREE_CODE (type) == REAL_TYPE);
1610}
1611
1612/* Create any builtin operator overload candidates for the operator in
1613 question given the converted operand types TYPE1 and TYPE2. The other
1614 args are passed through from add_builtin_candidates to
1615 build_builtin_candidate.
1616
1617 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1618 If CODE is requires candidates operands of the same type of the kind
1619 of which TYPE1 and TYPE2 are, we add both candidates
1620 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1621
1622static void
1623add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1624 enum tree_code code2, tree fnname, tree type1,
1625 tree type2, tree *args, tree *argtypes, int flags)
1626{
1627 switch (code)
1628 {
1629 case POSTINCREMENT_EXPR:
1630 case POSTDECREMENT_EXPR:
1631 args[1] = integer_zero_node;
1632 type2 = integer_type_node;
1633 break;
1634 default:
1635 break;
1636 }
1637
1638 switch (code)
1639 {
1640
1641/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1642 and VQ is either volatile or empty, there exist candidate operator
1643 functions of the form
1644 VQ T& operator++(VQ T&);
1645 T operator++(VQ T&, int);
1646 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1647 type other than bool, and VQ is either volatile or empty, there exist
1648 candidate operator functions of the form
1649 VQ T& operator--(VQ T&);
1650 T operator--(VQ T&, int);
1651 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1652 complete object type, and VQ is either volatile or empty, there exist
1653 candidate operator functions of the form
1654 T*VQ& operator++(T*VQ&);
1655 T*VQ& operator--(T*VQ&);
1656 T* operator++(T*VQ&, int);
1657 T* operator--(T*VQ&, int); */
1658
1659 case POSTDECREMENT_EXPR:
1660 case PREDECREMENT_EXPR:
1661 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1662 return;
1663 case POSTINCREMENT_EXPR:
1664 case PREINCREMENT_EXPR:
1665 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1666 {
1667 type1 = build_reference_type (type1);
1668 break;
1669 }
1670 return;
1671
1672/* 7 For every cv-qualified or cv-unqualified complete object type T, there
1673 exist candidate operator functions of the form
1674
1675 T& operator*(T*);
1676
1677 8 For every function type T, there exist candidate operator functions of
1678 the form
1679 T& operator*(T*); */
1680
1681 case INDIRECT_REF:
1682 if (TREE_CODE (type1) == POINTER_TYPE
1683 && (TYPE_PTROB_P (type1)
1684 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1685 break;
1686 return;
1687
1688/* 9 For every type T, there exist candidate operator functions of the form
1689 T* operator+(T*);
1690
1691 10For every promoted arithmetic type T, there exist candidate operator
1692 functions of the form
1693 T operator+(T);
1694 T operator-(T); */
1695
1696 case UNARY_PLUS_EXPR: /* unary + */
1697 if (TREE_CODE (type1) == POINTER_TYPE)
1698 break;
1699 case NEGATE_EXPR:
1700 if (ARITHMETIC_TYPE_P (type1))
1701 break;
1702 return;
1703
1704/* 11For every promoted integral type T, there exist candidate operator
1705 functions of the form
1706 T operator~(T); */
1707
1708 case BIT_NOT_EXPR:
1709 if (INTEGRAL_TYPE_P (type1))
1710 break;
1711 return;
1712
1713/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1714 is the same type as C2 or is a derived class of C2, T is a complete
1715 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1716 there exist candidate operator functions of the form
1717 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1718 where CV12 is the union of CV1 and CV2. */
1719
1720 case MEMBER_REF:
1721 if (TREE_CODE (type1) == POINTER_TYPE
1722 && TYPE_PTR_TO_MEMBER_P (type2))
1723 {
1724 tree c1 = TREE_TYPE (type1);
1725 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1726
1727 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1728 && (TYPE_PTRMEMFUNC_P (type2)
1729 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1730 break;
1731 }
1732 return;
1733
1734/* 13For every pair of promoted arithmetic types L and R, there exist can-
1735 didate operator functions of the form
1736 LR operator*(L, R);
1737 LR operator/(L, R);
1738 LR operator+(L, R);
1739 LR operator-(L, R);
1740 bool operator<(L, R);
1741 bool operator>(L, R);
1742 bool operator<=(L, R);
1743 bool operator>=(L, R);
1744 bool operator==(L, R);
1745 bool operator!=(L, R);
1746 where LR is the result of the usual arithmetic conversions between
1747 types L and R.
1748
1749 14For every pair of types T and I, where T is a cv-qualified or cv-
1750 unqualified complete object type and I is a promoted integral type,
1751 there exist candidate operator functions of the form
1752 T* operator+(T*, I);
1753 T& operator[](T*, I);
1754 T* operator-(T*, I);
1755 T* operator+(I, T*);
1756 T& operator[](I, T*);
1757
1758 15For every T, where T is a pointer to complete object type, there exist
1759 candidate operator functions of the form112)
1760 ptrdiff_t operator-(T, T);
1761
1762 16For every pointer or enumeration type T, there exist candidate operator
1763 functions of the form
1764 bool operator<(T, T);
1765 bool operator>(T, T);
1766 bool operator<=(T, T);
1767 bool operator>=(T, T);
1768 bool operator==(T, T);
1769 bool operator!=(T, T);
1770
1771 17For every pointer to member type T, there exist candidate operator
1772 functions of the form
1773 bool operator==(T, T);
1774 bool operator!=(T, T); */
1775
1776 case MINUS_EXPR:
1777 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1778 break;
1779 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1780 {
1781 type2 = ptrdiff_type_node;
1782 break;
1783 }
1784 case MULT_EXPR:
1785 case TRUNC_DIV_EXPR:
1786 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1787 break;
1788 return;
1789
1790 case EQ_EXPR:
1791 case NE_EXPR:
1792 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1793 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1794 break;
1795 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1796 {
1797 type2 = type1;
1798 break;
1799 }
1800 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1801 {
1802 type1 = type2;
1803 break;
1804 }
1805 /* Fall through. */
1806 case LT_EXPR:
1807 case GT_EXPR:
1808 case LE_EXPR:
1809 case GE_EXPR:
1810 case MAX_EXPR:
1811 case MIN_EXPR:
1812 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1813 break;
1814 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1815 break;
1816 if (TREE_CODE (type1) == ENUMERAL_TYPE
1817 && TREE_CODE (type2) == ENUMERAL_TYPE)
1818 break;
1819 if (TYPE_PTR_P (type1)
1820 && null_ptr_cst_p (args[1])
1821 && !uses_template_parms (type1))
1822 {
1823 type2 = type1;
1824 break;
1825 }
1826 if (null_ptr_cst_p (args[0])
1827 && TYPE_PTR_P (type2)
1828 && !uses_template_parms (type2))
1829 {
1830 type1 = type2;
1831 break;
1832 }
1833 return;
1834
1835 case PLUS_EXPR:
1836 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1837 break;
1838 case ARRAY_REF:
1839 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1840 {
1841 type1 = ptrdiff_type_node;
1842 break;
1843 }
1844 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1845 {
1846 type2 = ptrdiff_type_node;
1847 break;
1848 }
1849 return;
1850
1851/* 18For every pair of promoted integral types L and R, there exist candi-
1852 date operator functions of the form
1853 LR operator%(L, R);
1854 LR operator&(L, R);
1855 LR operator^(L, R);
1856 LR operator|(L, R);
1857 L operator<<(L, R);
1858 L operator>>(L, R);
1859 where LR is the result of the usual arithmetic conversions between
1860 types L and R. */
1861
1862 case TRUNC_MOD_EXPR:
1863 case BIT_AND_EXPR:
1864 case BIT_IOR_EXPR:
1865 case BIT_XOR_EXPR:
1866 case LSHIFT_EXPR:
1867 case RSHIFT_EXPR:
1868 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1869 break;
1870 return;
1871
1872/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1873 type, VQ is either volatile or empty, and R is a promoted arithmetic
1874 type, there exist candidate operator functions of the form
1875 VQ L& operator=(VQ L&, R);
1876 VQ L& operator*=(VQ L&, R);
1877 VQ L& operator/=(VQ L&, R);
1878 VQ L& operator+=(VQ L&, R);
1879 VQ L& operator-=(VQ L&, R);
1880
1881 20For every pair T, VQ), where T is any type and VQ is either volatile
1882 or empty, there exist candidate operator functions of the form
1883 T*VQ& operator=(T*VQ&, T*);
1884
1885 21For every pair T, VQ), where T is a pointer to member type and VQ is
1886 either volatile or empty, there exist candidate operator functions of
1887 the form
1888 VQ T& operator=(VQ T&, T);
1889
1890 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1891 unqualified complete object type, VQ is either volatile or empty, and
1892 I is a promoted integral type, there exist candidate operator func-
1893 tions of the form
1894 T*VQ& operator+=(T*VQ&, I);
1895 T*VQ& operator-=(T*VQ&, I);
1896
1897 23For every triple L, VQ, R), where L is an integral or enumeration
1898 type, VQ is either volatile or empty, and R is a promoted integral
1899 type, there exist candidate operator functions of the form
1900
1901 VQ L& operator%=(VQ L&, R);
1902 VQ L& operator<<=(VQ L&, R);
1903 VQ L& operator>>=(VQ L&, R);
1904 VQ L& operator&=(VQ L&, R);
1905 VQ L& operator^=(VQ L&, R);
1906 VQ L& operator|=(VQ L&, R); */
1907
1908 case MODIFY_EXPR:
1909 switch (code2)
1910 {
1911 case PLUS_EXPR:
1912 case MINUS_EXPR:
1913 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1914 {
1915 type2 = ptrdiff_type_node;
1916 break;
1917 }
1918 case MULT_EXPR:
1919 case TRUNC_DIV_EXPR:
1920 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1921 break;
1922 return;
1923
1924 case TRUNC_MOD_EXPR:
1925 case BIT_AND_EXPR:
1926 case BIT_IOR_EXPR:
1927 case BIT_XOR_EXPR:
1928 case LSHIFT_EXPR:
1929 case RSHIFT_EXPR:
1930 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1931 break;
1932 return;
1933
1934 case NOP_EXPR:
1935 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1936 break;
1937 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1938 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1939 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1940 || ((TYPE_PTRMEMFUNC_P (type1)
1941 || TREE_CODE (type1) == POINTER_TYPE)
1942 && null_ptr_cst_p (args[1])))
1943 {
1944 type2 = type1;
1945 break;
1946 }
1947 return;
1948
1949 default:
1950 gcc_unreachable ();
1951 }
1952 type1 = build_reference_type (type1);
1953 break;
1954
1955 case COND_EXPR:
1956 /* [over.built]
1957
1958 For every pair of promoted arithmetic types L and R, there
1959 exist candidate operator functions of the form
1960
1961 LR operator?(bool, L, R);
1962
1963 where LR is the result of the usual arithmetic conversions
1964 between types L and R.
1965
1966 For every type T, where T is a pointer or pointer-to-member
1967 type, there exist candidate operator functions of the form T
1968 operator?(bool, T, T); */
1969
1970 if (promoted_arithmetic_type_p (type1)
1971 && promoted_arithmetic_type_p (type2))
1972 /* That's OK. */
1973 break;
1974
1975 /* Otherwise, the types should be pointers. */
1976 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1977 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1978 return;
1979
1980 /* We don't check that the two types are the same; the logic
1981 below will actually create two candidates; one in which both
1982 parameter types are TYPE1, and one in which both parameter
1983 types are TYPE2. */
1984 break;
1985
1986 default:
1987 gcc_unreachable ();
1988 }
1989
1990 /* If we're dealing with two pointer types or two enumeral types,
1991 we need candidates for both of them. */
1992 if (type2 && !same_type_p (type1, type2)
1993 && TREE_CODE (type1) == TREE_CODE (type2)
1994 && (TREE_CODE (type1) == REFERENCE_TYPE
1995 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1996 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1997 || TYPE_PTRMEMFUNC_P (type1)
1998 || IS_AGGR_TYPE (type1)
1999 || TREE_CODE (type1) == ENUMERAL_TYPE))
2000 {
2001 build_builtin_candidate
2002 (candidates, fnname, type1, type1, args, argtypes, flags);
2003 build_builtin_candidate
2004 (candidates, fnname, type2, type2, args, argtypes, flags);
2005 return;
2006 }
2007
2008 build_builtin_candidate
2009 (candidates, fnname, type1, type2, args, argtypes, flags);
2010}
2011
2012tree
2013type_decays_to (tree type)
2014{
2015 if (TREE_CODE (type) == ARRAY_TYPE)
2016 return build_pointer_type (TREE_TYPE (type));
2017 if (TREE_CODE (type) == FUNCTION_TYPE)
2018 return build_pointer_type (type);
2019 return type;
2020}
2021
2022/* There are three conditions of builtin candidates:
2023
2024 1) bool-taking candidates. These are the same regardless of the input.
2025 2) pointer-pair taking candidates. These are generated for each type
2026 one of the input types converts to.
2027 3) arithmetic candidates. According to the standard, we should generate
2028 all of these, but I'm trying not to...
2029
2030 Here we generate a superset of the possible candidates for this particular
2031 case. That is a subset of the full set the standard defines, plus some
2032 other cases which the standard disallows. add_builtin_candidate will
2033 filter out the invalid set. */
2034
2035static void
2036add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2037 enum tree_code code2, tree fnname, tree *args,
2038 int flags)
2039{
2040 int ref1, i;
2041 int enum_p = 0;
2042 tree type, argtypes[3];
2043 /* TYPES[i] is the set of possible builtin-operator parameter types
2044 we will consider for the Ith argument. These are represented as
2045 a TREE_LIST; the TREE_VALUE of each node is the potential
2046 parameter type. */
2047 tree types[2];
2048
2049 for (i = 0; i < 3; ++i)
2050 {
2051 if (args[i])
2052 argtypes[i] = lvalue_type (args[i]);
2053 else
2054 argtypes[i] = NULL_TREE;
2055 }
2056
2057 switch (code)
2058 {
2059/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2060 and VQ is either volatile or empty, there exist candidate operator
2061 functions of the form
2062 VQ T& operator++(VQ T&); */
2063
2064 case POSTINCREMENT_EXPR:
2065 case PREINCREMENT_EXPR:
2066 case POSTDECREMENT_EXPR:
2067 case PREDECREMENT_EXPR:
2068 case MODIFY_EXPR:
2069 ref1 = 1;
2070 break;
2071
2072/* 24There also exist candidate operator functions of the form
2073 bool operator!(bool);
2074 bool operator&&(bool, bool);
2075 bool operator||(bool, bool); */
2076
2077 case TRUTH_NOT_EXPR:
2078 build_builtin_candidate
2079 (candidates, fnname, boolean_type_node,
2080 NULL_TREE, args, argtypes, flags);
2081 return;
2082
2083 case TRUTH_ORIF_EXPR:
2084 case TRUTH_ANDIF_EXPR:
2085 build_builtin_candidate
2086 (candidates, fnname, boolean_type_node,
2087 boolean_type_node, args, argtypes, flags);
2088 return;
2089
2090 case ADDR_EXPR:
2091 case COMPOUND_EXPR:
2092 case COMPONENT_REF:
2093 return;
2094
2095 case COND_EXPR:
2096 case EQ_EXPR:
2097 case NE_EXPR:
2098 case LT_EXPR:
2099 case LE_EXPR:
2100 case GT_EXPR:
2101 case GE_EXPR:
2102 enum_p = 1;
2103 /* Fall through. */
2104
2105 default:
2106 ref1 = 0;
2107 }
2108
2109 types[0] = types[1] = NULL_TREE;
2110
2111 for (i = 0; i < 2; ++i)
2112 {
2113 if (! args[i])
2114 ;
2115 else if (IS_AGGR_TYPE (argtypes[i]))
2116 {
2117 tree convs;
2118
2119 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2120 return;
2121
2122 convs = lookup_conversions (argtypes[i]);
2123
2124 if (code == COND_EXPR)
2125 {
2126 if (real_lvalue_p (args[i]))
2127 types[i] = tree_cons
2128 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2129
2130 types[i] = tree_cons
2131 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2132 }
2133
2134 else if (! convs)
2135 return;
2136
2137 for (; convs; convs = TREE_CHAIN (convs))
2138 {
2139 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2140
2141 if (i == 0 && ref1
2142 && (TREE_CODE (type) != REFERENCE_TYPE
2143 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2144 continue;
2145
2146 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2147 types[i] = tree_cons (NULL_TREE, type, types[i]);
2148
2149 type = non_reference (type);
2150 if (i != 0 || ! ref1)
2151 {
2152 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2153 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2154 types[i] = tree_cons (NULL_TREE, type, types[i]);
2155 if (INTEGRAL_TYPE_P (type))
2156 type = type_promotes_to (type);
2157 }
2158
2159 if (! value_member (type, types[i]))
2160 types[i] = tree_cons (NULL_TREE, type, types[i]);
2161 }
2162 }
2163 else
2164 {
2165 if (code == COND_EXPR && real_lvalue_p (args[i]))
2166 types[i] = tree_cons
2167 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2168 type = non_reference (argtypes[i]);
2169 if (i != 0 || ! ref1)
2170 {
2171 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2172 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2173 types[i] = tree_cons (NULL_TREE, type, types[i]);
2174 if (INTEGRAL_TYPE_P (type))
2175 type = type_promotes_to (type);
2176 }
2177 types[i] = tree_cons (NULL_TREE, type, types[i]);
2178 }
2179 }
2180
2181 /* Run through the possible parameter types of both arguments,
2182 creating candidates with those parameter types. */
2183 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2184 {
2185 if (types[1])
2186 for (type = types[1]; type; type = TREE_CHAIN (type))
2187 add_builtin_candidate
2188 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2189 TREE_VALUE (type), args, argtypes, flags);
2190 else
2191 add_builtin_candidate
2192 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2193 NULL_TREE, args, argtypes, flags);
2194 }
2195}
2196
2197
2198/* If TMPL can be successfully instantiated as indicated by
2199 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2200
2201 TMPL is the template. EXPLICIT_TARGS are any explicit template
2202 arguments. ARGLIST is the arguments provided at the call-site.
2203 The RETURN_TYPE is the desired type for conversion operators. If
2204 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2205 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2206 add_conv_candidate. */
2207
2208static struct z_candidate*
2209add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2210 tree ctype, tree explicit_targs, tree arglist,
2211 tree return_type, tree access_path,
2212 tree conversion_path, int flags, tree obj,
2213 unification_kind_t strict)
2214{
2215 int ntparms = DECL_NTPARMS (tmpl);
2216 tree targs = make_tree_vec (ntparms);
2217 tree args_without_in_chrg = arglist;
2218 struct z_candidate *cand;
2219 int i;
2220 tree fn;
2221
2222 /* We don't do deduction on the in-charge parameter, the VTT
2223 parameter or 'this'. */
2224 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2225 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2226
2227 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2228 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2229 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2230 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2231
2232 i = fn_type_unification (tmpl, explicit_targs, targs,
2233 args_without_in_chrg,
2234 return_type, strict, flags);
2235
2236 if (i != 0)
2237 return NULL;
2238
2239 fn = instantiate_template (tmpl, targs, tf_none);
2240 if (fn == error_mark_node)
2241 return NULL;
2242
2243 /* In [class.copy]:
2244
2245 A member function template is never instantiated to perform the
2246 copy of a class object to an object of its class type.
2247
2248 It's a little unclear what this means; the standard explicitly
2249 does allow a template to be used to copy a class. For example,
2250 in:
2251
2252 struct A {
2253 A(A&);
2254 template <class T> A(const T&);
2255 };
2256 const A f ();
2257 void g () { A a (f ()); }
2258
2259 the member template will be used to make the copy. The section
2260 quoted above appears in the paragraph that forbids constructors
2261 whose only parameter is (a possibly cv-qualified variant of) the
2262 class type, and a logical interpretation is that the intent was
2263 to forbid the instantiation of member templates which would then
2264 have that form. */
2265 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2266 {
2267 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2268 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2269 ctype))
2270 return NULL;
2271 }
2272
2273 if (obj != NULL_TREE)
2274 /* Aha, this is a conversion function. */
2275 cand = add_conv_candidate (candidates, fn, obj, access_path,
2276 conversion_path, arglist);
2277 else
2278 cand = add_function_candidate (candidates, fn, ctype,
2279 arglist, access_path,
2280 conversion_path, flags);
2281 if (DECL_TI_TEMPLATE (fn) != tmpl)
2282 /* This situation can occur if a member template of a template
2283 class is specialized. Then, instantiate_template might return
2284 an instantiation of the specialization, in which case the
2285 DECL_TI_TEMPLATE field will point at the original
2286 specialization. For example:
2287
2288 template <class T> struct S { template <class U> void f(U);
2289 template <> void f(int) {}; };
2290 S<double> sd;
2291 sd.f(3);
2292
2293 Here, TMPL will be template <class U> S<double>::f(U).
2294 And, instantiate template will give us the specialization
2295 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2296 for this will point at template <class T> template <> S<T>::f(int),
2297 so that we can find the definition. For the purposes of
2298 overload resolution, however, we want the original TMPL. */
2299 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2300 else
2301 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2302
2303 return cand;
2304}
2305
2306
2307static struct z_candidate *
2308add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2309 tree explicit_targs, tree arglist, tree return_type,
2310 tree access_path, tree conversion_path, int flags,
2311 unification_kind_t strict)
2312{
2313 return
2314 add_template_candidate_real (candidates, tmpl, ctype,
2315 explicit_targs, arglist, return_type,
2316 access_path, conversion_path,
2317 flags, NULL_TREE, strict);
2318}
2319
2320
2321static struct z_candidate *
2322add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2323 tree obj, tree arglist, tree return_type,
2324 tree access_path, tree conversion_path)
2325{
2326 return
2327 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2328 arglist, return_type, access_path,
2329 conversion_path, 0, obj, DEDUCE_CONV);
2330}
2331
2332/* The CANDS are the set of candidates that were considered for
2333 overload resolution. Return the set of viable candidates. If none
2334 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2335 is true if a candidate should be considered viable only if it is
2336 strictly viable. */
2337
2338static struct z_candidate*
2339splice_viable (struct z_candidate *cands,
2340 bool strict_p,
2341 bool *any_viable_p)
2342{
2343 struct z_candidate *viable;
2344 struct z_candidate **last_viable;
2345 struct z_candidate **cand;
2346
2347 viable = NULL;
2348 last_viable = &viable;
2349 *any_viable_p = false;
2350
2351 cand = &cands;
2352 while (*cand)
2353 {
2354 struct z_candidate *c = *cand;
2355 if (strict_p ? c->viable == 1 : c->viable)
2356 {
2357 *last_viable = c;
2358 *cand = c->next;
2359 c->next = NULL;
2360 last_viable = &c->next;
2361 *any_viable_p = true;
2362 }
2363 else
2364 cand = &c->next;
2365 }
2366
2367 return viable ? viable : cands;
2368}
2369
2370static bool
2371any_strictly_viable (struct z_candidate *cands)
2372{
2373 for (; cands; cands = cands->next)
2374 if (cands->viable == 1)
2375 return true;
2376 return false;
2377}
2378
2379/* OBJ is being used in an expression like "OBJ.f (...)". In other
2380 words, it is about to become the "this" pointer for a member
2381 function call. Take the address of the object. */
2382
2383static tree
2384build_this (tree obj)
2385{
2386 /* In a template, we are only concerned about the type of the
2387 expression, so we can take a shortcut. */
2388 if (processing_template_decl)
2389 return build_address (obj);
2390
2391 return build_unary_op (ADDR_EXPR, obj, 0);
2392}
2393
2394/* Returns true iff functions are equivalent. Equivalent functions are
2395 not '==' only if one is a function-local extern function or if
2396 both are extern "C". */
2397
2398static inline int
2399equal_functions (tree fn1, tree fn2)
2400{
2401 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2402 || DECL_EXTERN_C_FUNCTION_P (fn1))
2403 return decls_match (fn1, fn2);
2404 return fn1 == fn2;
2405}
2406
2407/* Print information about one overload candidate CANDIDATE. MSGSTR
2408 is the text to print before the candidate itself.
2409
2410 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2411 to have been run through gettext by the caller. This wart makes
2412 life simpler in print_z_candidates and for the translators. */
2413
2414static void
2415print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2416{
2417 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2418 {
2419 if (candidate->num_convs == 3)
2420 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2421 candidate->convs[0]->type,
2422 candidate->convs[1]->type,
2423 candidate->convs[2]->type);
2424 else if (candidate->num_convs == 2)
2425 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2426 candidate->convs[0]->type,
2427 candidate->convs[1]->type);
2428 else
2429 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2430 candidate->convs[0]->type);
2431 }
2432 else if (TYPE_P (candidate->fn))
2433 inform ("%s %T <conversion>", msgstr, candidate->fn);
2434 else if (candidate->viable == -1)
2435 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2436 else
2437 inform ("%s %+#D", msgstr, candidate->fn);
2438}
2439
2440static void
2441print_z_candidates (struct z_candidate *candidates)
2442{
2443 const char *str;
2444 struct z_candidate *cand1;
2445 struct z_candidate **cand2;
2446
2447 /* There may be duplicates in the set of candidates. We put off
2448 checking this condition as long as possible, since we have no way
2449 to eliminate duplicates from a set of functions in less than n^2
2450 time. Now we are about to emit an error message, so it is more
2451 permissible to go slowly. */
2452 for (cand1 = candidates; cand1; cand1 = cand1->next)
2453 {
2454 tree fn = cand1->fn;
2455 /* Skip builtin candidates and conversion functions. */
2456 if (TREE_CODE (fn) != FUNCTION_DECL)
2457 continue;
2458 cand2 = &cand1->next;
2459 while (*cand2)
2460 {
2461 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2462 && equal_functions (fn, (*cand2)->fn))
2463 *cand2 = (*cand2)->next;
2464 else
2465 cand2 = &(*cand2)->next;
2466 }
2467 }
2468
2469 if (!candidates)
2470 return;
2471
2472 str = _("candidates are:");
2473 print_z_candidate (str, candidates);
2474 if (candidates->next)
2475 {
2476 /* Indent successive candidates by the width of the translation
2477 of the above string. */
2478 size_t len = gcc_gettext_width (str) + 1;
2479 char *spaces = (char *) alloca (len);
2480 memset (spaces, ' ', len-1);
2481 spaces[len - 1] = '\0';
2482
2483 candidates = candidates->next;
2484 do
2485 {
2486 print_z_candidate (spaces, candidates);
2487 candidates = candidates->next;
2488 }
2489 while (candidates);
2490 }
2491}
2492
2493/* USER_SEQ is a user-defined conversion sequence, beginning with a
2494 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2495 the result of the conversion function to convert it to the final
2496 desired type. Merge the two sequences into a single sequence,
2497 and return the merged sequence. */
2498
2499static conversion *
2500merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2501{
2502 conversion **t;
2503
2504 gcc_assert (user_seq->kind == ck_user);
2505
2506 /* Find the end of the second conversion sequence. */
2507 t = &(std_seq);
2508 while ((*t)->kind != ck_identity)
2509 t = &((*t)->u.next);
2510
2511 /* Replace the identity conversion with the user conversion
2512 sequence. */
2513 *t = user_seq;
2514
2515 /* The entire sequence is a user-conversion sequence. */
2516 std_seq->user_conv_p = true;
2517
2518 return std_seq;
2519}
2520
2521/* Returns the best overload candidate to perform the requested
2522 conversion. This function is used for three the overloading situations
2523 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2524 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2525 per [dcl.init.ref], so we ignore temporary bindings. */
2526
2527static struct z_candidate *
2528build_user_type_conversion_1 (tree totype, tree expr, int flags)
2529{
2530 struct z_candidate *candidates, *cand;
2531 tree fromtype = TREE_TYPE (expr);
2532 tree ctors = NULL_TREE;
2533 tree conv_fns = NULL_TREE;
2534 conversion *conv = NULL;
2535 tree args = NULL_TREE;
2536 bool any_viable_p;
2537
2538 /* We represent conversion within a hierarchy using RVALUE_CONV and
2539 BASE_CONV, as specified by [over.best.ics]; these become plain
2540 constructor calls, as specified in [dcl.init]. */
2541 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2542 || !DERIVED_FROM_P (totype, fromtype));
2543
2544 if (IS_AGGR_TYPE (totype))
2545 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2546
2547 if (IS_AGGR_TYPE (fromtype))
2548 conv_fns = lookup_conversions (fromtype);
2549
2550 candidates = 0;
2551 flags |= LOOKUP_NO_CONVERSION;
2552
2553 if (ctors)
2554 {
2555 tree t;
2556
2557 ctors = BASELINK_FUNCTIONS (ctors);
2558
2559 t = build_int_cst (build_pointer_type (totype), 0);
2560 args = build_tree_list (NULL_TREE, expr);
2561 /* We should never try to call the abstract or base constructor
2562 from here. */
2563 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2564 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2565 args = tree_cons (NULL_TREE, t, args);
2566 }
2567 for (; ctors; ctors = OVL_NEXT (ctors))
2568 {
2569 tree ctor = OVL_CURRENT (ctors);
2570 if (DECL_NONCONVERTING_P (ctor))
2571 continue;
2572
2573 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2574 cand = add_template_candidate (&candidates, ctor, totype,
2575 NULL_TREE, args, NULL_TREE,
2576 TYPE_BINFO (totype),
2577 TYPE_BINFO (totype),
2578 flags,
2579 DEDUCE_CALL);
2580 else
2581 cand = add_function_candidate (&candidates, ctor, totype,
2582 args, TYPE_BINFO (totype),
2583 TYPE_BINFO (totype),
2584 flags);
2585
2586 if (cand)
2587 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2588 }
2589
2590 if (conv_fns)
2591 args = build_tree_list (NULL_TREE, build_this (expr));
2592
2593 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2594 {
2595 tree fns;
2596 tree conversion_path = TREE_PURPOSE (conv_fns);
2597 int convflags = LOOKUP_NO_CONVERSION;
2598
2599 /* If we are called to convert to a reference type, we are trying to
2600 find an lvalue binding, so don't even consider temporaries. If
2601 we don't find an lvalue binding, the caller will try again to
2602 look for a temporary binding. */
2603 if (TREE_CODE (totype) == REFERENCE_TYPE)
2604 convflags |= LOOKUP_NO_TEMP_BIND;
2605
2606 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2607 {
2608 tree fn = OVL_CURRENT (fns);
2609
2610 /* [over.match.funcs] For conversion functions, the function
2611 is considered to be a member of the class of the implicit
2612 object argument for the purpose of defining the type of
2613 the implicit object parameter.
2614
2615 So we pass fromtype as CTYPE to add_*_candidate. */
2616
2617 if (TREE_CODE (fn) == TEMPLATE_DECL)
2618 cand = add_template_candidate (&candidates, fn, fromtype,
2619 NULL_TREE,
2620 args, totype,
2621 TYPE_BINFO (fromtype),
2622 conversion_path,
2623 flags,
2624 DEDUCE_CONV);
2625 else
2626 cand = add_function_candidate (&candidates, fn, fromtype,
2627 args,
2628 TYPE_BINFO (fromtype),
2629 conversion_path,
2630 flags);
2631
2632 if (cand)
2633 {
2634 conversion *ics
2635 = implicit_conversion (totype,
2636 TREE_TYPE (TREE_TYPE (cand->fn)),
2637 0,
2638 /*c_cast_p=*/false, convflags);
2639
2640 cand->second_conv = ics;
2641
2642 if (!ics)
2643 cand->viable = 0;
2644 else if (candidates->viable == 1 && ics->bad_p)
2645 cand->viable = -1;
2646 }
2647 }
2648 }
2649
2650 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2651 if (!any_viable_p)
2652 return NULL;
2653
2654 cand = tourney (candidates);
2655 if (cand == 0)
2656 {
2657 if (flags & LOOKUP_COMPLAIN)
2658 {
2659 error ("conversion from %qT to %qT is ambiguous",
2660 fromtype, totype);
2661 print_z_candidates (candidates);
2662 }
2663
2664 cand = candidates; /* any one will do */
2665 cand->second_conv = build_ambiguous_conv (totype, expr);
2666 cand->second_conv->user_conv_p = true;
2667 if (!any_strictly_viable (candidates))
2668 cand->second_conv->bad_p = true;
2669 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2670 ambiguous conversion is no worse than another user-defined
2671 conversion. */
2672
2673 return cand;
2674 }
2675
2676 /* Build the user conversion sequence. */
2677 conv = build_conv
2678 (ck_user,
2679 (DECL_CONSTRUCTOR_P (cand->fn)
2680 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2681 build_identity_conv (TREE_TYPE (expr), expr));
2682 conv->cand = cand;
2683
2684 /* Combine it with the second conversion sequence. */
2685 cand->second_conv = merge_conversion_sequences (conv,
2686 cand->second_conv);
2687
2688 if (cand->viable == -1)
2689 cand->second_conv->bad_p = true;
2690
2691 return cand;
2692}
2693
2694tree
2695build_user_type_conversion (tree totype, tree expr, int flags)
2696{
2697 struct z_candidate *cand
2698 = build_user_type_conversion_1 (totype, expr, flags);
2699
2700 if (cand)
2701 {
2702 if (cand->second_conv->kind == ck_ambig)
2703 return error_mark_node;
2704 expr = convert_like (cand->second_conv, expr);
2705 return convert_from_reference (expr);
2706 }
2707 return NULL_TREE;
2708}
2709
2710/* Do any initial processing on the arguments to a function call. */
2711
2712static tree
2713resolve_args (tree args)
2714{
2715 tree t;
2716 for (t = args; t; t = TREE_CHAIN (t))
2717 {
2718 tree arg = TREE_VALUE (t);
2719
2720 if (error_operand_p (arg))
2721 return error_mark_node;
2722 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2723 {
2724 error ("invalid use of void expression");
2725 return error_mark_node;
2726 }
2727 else if (invalid_nonstatic_memfn_p (arg))
2728 return error_mark_node;
2729 }
2730 return args;
2731}
2732
2733/* Perform overload resolution on FN, which is called with the ARGS.
2734
2735 Return the candidate function selected by overload resolution, or
2736 NULL if the event that overload resolution failed. In the case
2737 that overload resolution fails, *CANDIDATES will be the set of
2738 candidates considered, and ANY_VIABLE_P will be set to true or
2739 false to indicate whether or not any of the candidates were
2740 viable.
2741
2742 The ARGS should already have gone through RESOLVE_ARGS before this
2743 function is called. */
2744
2745static struct z_candidate *
2746perform_overload_resolution (tree fn,
2747 tree args,
2748 struct z_candidate **candidates,
2749 bool *any_viable_p)
2750{
2751 struct z_candidate *cand;
2752 tree explicit_targs = NULL_TREE;
2753 int template_only = 0;
2754
2755 *candidates = NULL;
2756 *any_viable_p = true;
2757
2758 /* Check FN and ARGS. */
2759 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2760 || TREE_CODE (fn) == TEMPLATE_DECL
2761 || TREE_CODE (fn) == OVERLOAD
2762 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2763 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2764
2765 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2766 {
2767 explicit_targs = TREE_OPERAND (fn, 1);
2768 fn = TREE_OPERAND (fn, 0);
2769 template_only = 1;
2770 }
2771
2772 /* Add the various candidate functions. */
2773 add_candidates (fn, args, explicit_targs, template_only,
2774 /*conversion_path=*/NULL_TREE,
2775 /*access_path=*/NULL_TREE,
2776 LOOKUP_NORMAL,
2777 candidates);
2778
2779 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2780 if (!*any_viable_p)
2781 return NULL;
2782
2783 cand = tourney (*candidates);
2784 return cand;
2785}
2786
2787/* Return an expression for a call to FN (a namespace-scope function,
2788 or a static member function) with the ARGS. */
2789
2790tree
2791build_new_function_call (tree fn, tree args, bool koenig_p)
2792{
2793 struct z_candidate *candidates, *cand;
2794 bool any_viable_p;
2795 void *p;
2796 tree result;
2797
2798 args = resolve_args (args);
2799 if (args == error_mark_node)
2800 return error_mark_node;
2801
2802 /* If this function was found without using argument dependent
2803 lookup, then we want to ignore any undeclared friend
2804 functions. */
2805 if (!koenig_p)
2806 {
2807 tree orig_fn = fn;
2808
2809 fn = remove_hidden_names (fn);
2810 if (!fn)
2811 {
2812 error ("no matching function for call to %<%D(%A)%>",
2813 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2814 return error_mark_node;
2815 }
2816 }
2817
2818 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2819 p = conversion_obstack_alloc (0);
2820
2821 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2822
2823 if (!cand)
2824 {
2825 if (!any_viable_p && candidates && ! candidates->next)
2826 return build_function_call (candidates->fn, args);
2827 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2828 fn = TREE_OPERAND (fn, 0);
2829 if (!any_viable_p)
2830 error ("no matching function for call to %<%D(%A)%>",
2831 DECL_NAME (OVL_CURRENT (fn)), args);
2832 else
2833 error ("call of overloaded %<%D(%A)%> is ambiguous",
2834 DECL_NAME (OVL_CURRENT (fn)), args);
2835 if (candidates)
2836 print_z_candidates (candidates);
2837 result = error_mark_node;
2838 }
2839 else
2840 result = build_over_call (cand, LOOKUP_NORMAL);
2841
2842 /* Free all the conversions we allocated. */
2843 obstack_free (&conversion_obstack, p);
2844
2845 return result;
2846}
2847
2848/* Build a call to a global operator new. FNNAME is the name of the
2849 operator (either "operator new" or "operator new[]") and ARGS are
2850 the arguments provided. *SIZE points to the total number of bytes
2851 required by the allocation, and is updated if that is changed here.
2852 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2853 function determines that no cookie should be used, after all,
2854 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2855 set, upon return, to the allocation function called. */
2856
2857tree
2858build_operator_new_call (tree fnname, tree args,
2859 tree *size, tree *cookie_size,
2860 tree *fn)
2861{
2862 tree fns;
2863 struct z_candidate *candidates;
2864 struct z_candidate *cand;
2865 bool any_viable_p;
2866
2867 if (fn)
2868 *fn = NULL_TREE;
2869 args = tree_cons (NULL_TREE, *size, args);
2870 args = resolve_args (args);
2871 if (args == error_mark_node)
2872 return args;
2873
2874 /* Based on:
2875
2876 [expr.new]
2877
2878 If this lookup fails to find the name, or if the allocated type
2879 is not a class type, the allocation function's name is looked
2880 up in the global scope.
2881
2882 we disregard block-scope declarations of "operator new". */
2883 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2884
2885 /* Figure out what function is being called. */
2886 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2887
2888 /* If no suitable function could be found, issue an error message
2889 and give up. */
2890 if (!cand)
2891 {
2892 if (!any_viable_p)
2893 error ("no matching function for call to %<%D(%A)%>",
2894 DECL_NAME (OVL_CURRENT (fns)), args);
2895 else
2896 error ("call of overloaded %<%D(%A)%> is ambiguous",
2897 DECL_NAME (OVL_CURRENT (fns)), args);
2898 if (candidates)
2899 print_z_candidates (candidates);
2900 return error_mark_node;
2901 }
2902
2903 /* If a cookie is required, add some extra space. Whether
2904 or not a cookie is required cannot be determined until
2905 after we know which function was called. */
2906 if (*cookie_size)
2907 {
2908 bool use_cookie = true;
2909 if (!abi_version_at_least (2))
2910 {
2911 tree placement = TREE_CHAIN (args);
2912 /* In G++ 3.2, the check was implemented incorrectly; it
2913 looked at the placement expression, rather than the
2914 type of the function. */
2915 if (placement && !TREE_CHAIN (placement)
2916 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2917 ptr_type_node))
2918 use_cookie = false;
2919 }
2920 else
2921 {
2922 tree arg_types;
2923
2924 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2925 /* Skip the size_t parameter. */
2926 arg_types = TREE_CHAIN (arg_types);
2927 /* Check the remaining parameters (if any). */
2928 if (arg_types
2929 && TREE_CHAIN (arg_types) == void_list_node
2930 && same_type_p (TREE_VALUE (arg_types),
2931 ptr_type_node))
2932 use_cookie = false;
2933 }
2934 /* If we need a cookie, adjust the number of bytes allocated. */
2935 if (use_cookie)
2936 {
2937 /* Update the total size. */
2938 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2939 /* Update the argument list to reflect the adjusted size. */
2940 TREE_VALUE (args) = *size;
2941 }
2942 else
2943 *cookie_size = NULL_TREE;
2944 }
2945
2946 /* Tell our caller which function we decided to call. */
2947 if (fn)
2948 *fn = cand->fn;
2949
2950 /* Build the CALL_EXPR. */
2951 return build_over_call (cand, LOOKUP_NORMAL);
2952}
2953
2954static tree
2955build_object_call (tree obj, tree args)
2956{
2957 struct z_candidate *candidates = 0, *cand;
2958 tree fns, convs, mem_args = NULL_TREE;
2959 tree type = TREE_TYPE (obj);
2960 bool any_viable_p;
2961 tree result = NULL_TREE;
2962 void *p;
2963
2964 if (TYPE_PTRMEMFUNC_P (type))
2965 {
2966 /* It's no good looking for an overloaded operator() on a
2967 pointer-to-member-function. */
2968 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2969 return error_mark_node;
2970 }
2971
2972 if (TYPE_BINFO (type))
2973 {
2974 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2975 if (fns == error_mark_node)
2976 return error_mark_node;
2977 }
2978 else
2979 fns = NULL_TREE;
2980
2981 args = resolve_args (args);
2982
2983 if (args == error_mark_node)
2984 return error_mark_node;
2985
2986 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2987 p = conversion_obstack_alloc (0);
2988
2989 if (fns)
2990 {
2991 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2992 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2993
2994 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2995 {
2996 tree fn = OVL_CURRENT (fns);
2997 if (TREE_CODE (fn) == TEMPLATE_DECL)
2998 add_template_candidate (&candidates, fn, base, NULL_TREE,
2999 mem_args, NULL_TREE,
3000 TYPE_BINFO (type),
3001 TYPE_BINFO (type),
3002 LOOKUP_NORMAL, DEDUCE_CALL);
3003 else
3004 add_function_candidate
3005 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3006 TYPE_BINFO (type), LOOKUP_NORMAL);
3007 }
3008 }
3009
3010 convs = lookup_conversions (type);
3011
3012 for (; convs; convs = TREE_CHAIN (convs))
3013 {
3014 tree fns = TREE_VALUE (convs);
3015 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3016
3017 if ((TREE_CODE (totype) == POINTER_TYPE
3018 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3019 || (TREE_CODE (totype) == REFERENCE_TYPE
3020 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3021 || (TREE_CODE (totype) == REFERENCE_TYPE
3022 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3023 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3024 for (; fns; fns = OVL_NEXT (fns))
3025 {
3026 tree fn = OVL_CURRENT (fns);
3027 if (TREE_CODE (fn) == TEMPLATE_DECL)
3028 add_template_conv_candidate
3029 (&candidates, fn, obj, args, totype,
3030 /*access_path=*/NULL_TREE,
3031 /*conversion_path=*/NULL_TREE);
3032 else
3033 add_conv_candidate (&candidates, fn, obj, args,
3034 /*conversion_path=*/NULL_TREE,
3035 /*access_path=*/NULL_TREE);
3036 }
3037 }
3038
3039 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3040 if (!any_viable_p)
3041 {
3042 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3043 print_z_candidates (candidates);
3044 result = error_mark_node;
3045 }
3046 else
3047 {
3048 cand = tourney (candidates);
3049 if (cand == 0)
3050 {
3051 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3052 print_z_candidates (candidates);
3053 result = error_mark_node;
3054 }
3055 /* Since cand->fn will be a type, not a function, for a conversion
3056 function, we must be careful not to unconditionally look at
3057 DECL_NAME here. */
3058 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3059 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3060 result = build_over_call (cand, LOOKUP_NORMAL);
3061 else
3062 {
3063 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3064 obj = convert_from_reference (obj);
3065 result = build_function_call (obj, args);
3066 }
3067 }
3068
3069 /* Free all the conversions we allocated. */
3070 obstack_free (&conversion_obstack, p);
3071
3072 return result;
3073}
3074
3075static void
3076op_error (enum tree_code code, enum tree_code code2,
3077 tree arg1, tree arg2, tree arg3, const char *problem)
3078{
3079 const char *opname;
3080
3081 if (code == MODIFY_EXPR)
3082 opname = assignment_operator_name_info[code2].name;
3083 else
3084 opname = operator_name_info[code].name;
3085
3086 switch (code)
3087 {
3088 case COND_EXPR:
3089 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3090 problem, arg1, arg2, arg3);
3091 break;
3092
3093 case POSTINCREMENT_EXPR:
3094 case POSTDECREMENT_EXPR:
3095 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3096 break;
3097
3098 case ARRAY_REF:
3099 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3100 break;
3101
3102 case REALPART_EXPR:
3103 case IMAGPART_EXPR:
3104 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3105 break;
3106
3107 default:
3108 if (arg2)
3109 error ("%s for %<operator%s%> in %<%E %s %E%>",
3110 problem, opname, arg1, opname, arg2);
3111 else
3112 error ("%s for %<operator%s%> in %<%s%E%>",
3113 problem, opname, opname, arg1);
3114 break;
3115 }
3116}
3117
3118/* Return the implicit conversion sequence that could be used to
3119 convert E1 to E2 in [expr.cond]. */
3120
3121static conversion *
3122conditional_conversion (tree e1, tree e2)
3123{
3124 tree t1 = non_reference (TREE_TYPE (e1));
3125 tree t2 = non_reference (TREE_TYPE (e2));
3126 conversion *conv;
3127 bool good_base;
3128
3129 /* [expr.cond]
3130
3131 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3132 implicitly converted (clause _conv_) to the type "reference to
3133 T2", subject to the constraint that in the conversion the
3134 reference must bind directly (_dcl.init.ref_) to E1. */
3135 if (real_lvalue_p (e2))
3136 {
3137 conv = implicit_conversion (build_reference_type (t2),
3138 t1,
3139 e1,
3140 /*c_cast_p=*/false,
3141 LOOKUP_NO_TEMP_BIND);
3142 if (conv)
3143 return conv;
3144 }
3145
3146 /* [expr.cond]
3147
3148 If E1 and E2 have class type, and the underlying class types are
3149 the same or one is a base class of the other: E1 can be converted
3150 to match E2 if the class of T2 is the same type as, or a base
3151 class of, the class of T1, and the cv-qualification of T2 is the
3152 same cv-qualification as, or a greater cv-qualification than, the
3153 cv-qualification of T1. If the conversion is applied, E1 is
3154 changed to an rvalue of type T2 that still refers to the original
3155 source class object (or the appropriate subobject thereof). */
3156 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3157 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3158 {
3159 if (good_base && at_least_as_qualified_p (t2, t1))
3160 {
3161 conv = build_identity_conv (t1, e1);
3162 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3163 TYPE_MAIN_VARIANT (t2)))
3164 conv = build_conv (ck_base, t2, conv);
3165 else
3166 conv = build_conv (ck_rvalue, t2, conv);
3167 return conv;
3168 }
3169 else
3170 return NULL;
3171 }
3172 else
3173 /* [expr.cond]
3174
3175 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3176 converted to the type that expression E2 would have if E2 were
3177 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3178 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3179 LOOKUP_NORMAL);
3180}
3181
3182/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3183 arguments to the conditional expression. */
3184
3185tree
3186build_conditional_expr (tree arg1, tree arg2, tree arg3)
3187{
3188 tree arg2_type;
3189 tree arg3_type;
3190 tree result = NULL_TREE;
3191 tree result_type = NULL_TREE;
3192 bool lvalue_p = true;
3193 struct z_candidate *candidates = 0;
3194 struct z_candidate *cand;
3195 void *p;
3196
3197 /* As a G++ extension, the second argument to the conditional can be
3198 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3199 c'.) If the second operand is omitted, make sure it is
3200 calculated only once. */
3201 if (!arg2)
3202 {
3203 if (pedantic)
3204 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3205
3206 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3207 if (real_lvalue_p (arg1))
3208 arg2 = arg1 = stabilize_reference (arg1);
3209 else
3210 arg2 = arg1 = save_expr (arg1);
3211 }
3212
3213 /* [expr.cond]
3214
3215 The first expr ession is implicitly converted to bool (clause
3216 _conv_). */
3217 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3218
3219 /* If something has already gone wrong, just pass that fact up the
3220 tree. */
3221 if (error_operand_p (arg1)
3222 || error_operand_p (arg2)
3223 || error_operand_p (arg3))
3224 return error_mark_node;
3225
3226 /* [expr.cond]
3227
3228 If either the second or the third operand has type (possibly
3229 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3230 array-to-pointer (_conv.array_), and function-to-pointer
3231 (_conv.func_) standard conversions are performed on the second
3232 and third operands. */
3233 arg2_type = unlowered_expr_type (arg2);
3234 arg3_type = unlowered_expr_type (arg3);
3235 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3236 {
3237 /* Do the conversions. We don't these for `void' type arguments
3238 since it can't have any effect and since decay_conversion
3239 does not handle that case gracefully. */
3240 if (!VOID_TYPE_P (arg2_type))
3241 arg2 = decay_conversion (arg2);
3242 if (!VOID_TYPE_P (arg3_type))
3243 arg3 = decay_conversion (arg3);
3244 arg2_type = TREE_TYPE (arg2);
3245 arg3_type = TREE_TYPE (arg3);
3246
3247 /* [expr.cond]
3248
3249 One of the following shall hold:
3250
3251 --The second or the third operand (but not both) is a
3252 throw-expression (_except.throw_); the result is of the
3253 type of the other and is an rvalue.
3254
3255 --Both the second and the third operands have type void; the
3256 result is of type void and is an rvalue.
3257
3258 We must avoid calling force_rvalue for expressions of type
3259 "void" because it will complain that their value is being
3260 used. */
3261 if (TREE_CODE (arg2) == THROW_EXPR
3262 && TREE_CODE (arg3) != THROW_EXPR)
3263 {
3264 if (!VOID_TYPE_P (arg3_type))
3265 arg3 = force_rvalue (arg3);
3266 arg3_type = TREE_TYPE (arg3);
3267 result_type = arg3_type;
3268 }
3269 else if (TREE_CODE (arg2) != THROW_EXPR
3270 && TREE_CODE (arg3) == THROW_EXPR)
3271 {
3272 if (!VOID_TYPE_P (arg2_type))
3273 arg2 = force_rvalue (arg2);
3274 arg2_type = TREE_TYPE (arg2);
3275 result_type = arg2_type;
3276 }
3277 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3278 result_type = void_type_node;
3279 else
3280 {
3281 error ("%qE has type %<void%> and is not a throw-expression",
3282 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3283 return error_mark_node;
3284 }
3285
3286 lvalue_p = false;
3287 goto valid_operands;
3288 }
3289 /* [expr.cond]
3290
3291 Otherwise, if the second and third operand have different types,
3292 and either has (possibly cv-qualified) class type, an attempt is
3293 made to convert each of those operands to the type of the other. */
3294 else if (!same_type_p (arg2_type, arg3_type)
3295 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3296 {
3297 conversion *conv2;
3298 conversion *conv3;
3299
3300 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3301 p = conversion_obstack_alloc (0);
3302
3303 conv2 = conditional_conversion (arg2, arg3);
3304 conv3 = conditional_conversion (arg3, arg2);
3305
3306 /* [expr.cond]
3307
3308 If both can be converted, or one can be converted but the
3309 conversion is ambiguous, the program is ill-formed. If
3310 neither can be converted, the operands are left unchanged and
3311 further checking is performed as described below. If exactly
3312 one conversion is possible, that conversion is applied to the
3313 chosen operand and the converted operand is used in place of
3314 the original operand for the remainder of this section. */
3315 if ((conv2 && !conv2->bad_p
3316 && conv3 && !conv3->bad_p)
3317 || (conv2 && conv2->kind == ck_ambig)
3318 || (conv3 && conv3->kind == ck_ambig))
3319 {
3320 error ("operands to ?: have different types %qT and %qT",
3321 arg2_type, arg3_type);
3322 result = error_mark_node;
3323 }
3324 else if (conv2 && (!conv2->bad_p || !conv3))
3325 {
3326 arg2 = convert_like (conv2, arg2);
3327 arg2 = convert_from_reference (arg2);
3328 arg2_type = TREE_TYPE (arg2);
3329 /* Even if CONV2 is a valid conversion, the result of the
3330 conversion may be invalid. For example, if ARG3 has type
3331 "volatile X", and X does not have a copy constructor
3332 accepting a "volatile X&", then even if ARG2 can be
3333 converted to X, the conversion will fail. */
3334 if (error_operand_p (arg2))
3335 result = error_mark_node;
3336 }
3337 else if (conv3 && (!conv3->bad_p || !conv2))
3338 {
3339 arg3 = convert_like (conv3, arg3);
3340 arg3 = convert_from_reference (arg3);
3341 arg3_type = TREE_TYPE (arg3);
3342 if (error_operand_p (arg3))
3343 result = error_mark_node;
3344 }
3345
3346 /* Free all the conversions we allocated. */
3347 obstack_free (&conversion_obstack, p);
3348
3349 if (result)
3350 return result;
3351
3352 /* If, after the conversion, both operands have class type,
3353 treat the cv-qualification of both operands as if it were the
3354 union of the cv-qualification of the operands.
3355
3356 The standard is not clear about what to do in this
3357 circumstance. For example, if the first operand has type
3358 "const X" and the second operand has a user-defined
3359 conversion to "volatile X", what is the type of the second
3360 operand after this step? Making it be "const X" (matching
3361 the first operand) seems wrong, as that discards the
3362 qualification without actually performing a copy. Leaving it
3363 as "volatile X" seems wrong as that will result in the
3364 conditional expression failing altogether, even though,
3365 according to this step, the one operand could be converted to
3366 the type of the other. */
3367 if ((conv2 || conv3)
3368 && CLASS_TYPE_P (arg2_type)
3369 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3370 arg2_type = arg3_type =
3371 cp_build_qualified_type (arg2_type,
3372 TYPE_QUALS (arg2_type)
3373 | TYPE_QUALS (arg3_type));
3374 }
3375
3376 /* [expr.cond]
3377
3378 If the second and third operands are lvalues and have the same
3379 type, the result is of that type and is an lvalue. */
3380 if (real_lvalue_p (arg2)
3381 && real_lvalue_p (arg3)
3382 && same_type_p (arg2_type, arg3_type))
3383 {
3384 result_type = arg2_type;
3385 goto valid_operands;
3386 }
3387
3388 /* [expr.cond]
3389
3390 Otherwise, the result is an rvalue. If the second and third
3391 operand do not have the same type, and either has (possibly
3392 cv-qualified) class type, overload resolution is used to
3393 determine the conversions (if any) to be applied to the operands
3394 (_over.match.oper_, _over.built_). */
3395 lvalue_p = false;
3396 if (!same_type_p (arg2_type, arg3_type)
3397 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3398 {
3399 tree args[3];
3400 conversion *conv;
3401 bool any_viable_p;
3402
3403 /* Rearrange the arguments so that add_builtin_candidate only has
3404 to know about two args. In build_builtin_candidates, the
3405 arguments are unscrambled. */
3406 args[0] = arg2;
3407 args[1] = arg3;
3408 args[2] = arg1;
3409 add_builtin_candidates (&candidates,
3410 COND_EXPR,
3411 NOP_EXPR,
3412 ansi_opname (COND_EXPR),
3413 args,
3414 LOOKUP_NORMAL);
3415
3416 /* [expr.cond]
3417
3418 If the overload resolution fails, the program is
3419 ill-formed. */
3420 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3421 if (!any_viable_p)
3422 {
3423 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3424 print_z_candidates (candidates);
3425 return error_mark_node;
3426 }
3427 cand = tourney (candidates);
3428 if (!cand)
3429 {
3430 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3431 print_z_candidates (candidates);
3432 return error_mark_node;
3433 }
3434
3435 /* [expr.cond]
3436
3437 Otherwise, the conversions thus determined are applied, and
3438 the converted operands are used in place of the original
3439 operands for the remainder of this section. */
3440 conv = cand->convs[0];
3441 arg1 = convert_like (conv, arg1);
3442 conv = cand->convs[1];
3443 arg2 = convert_like (conv, arg2);
3444 conv = cand->convs[2];
3445 arg3 = convert_like (conv, arg3);
3446 }
3447
3448 /* [expr.cond]
3449
3450 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3451 and function-to-pointer (_conv.func_) standard conversions are
3452 performed on the second and third operands.
3453
3454 We need to force the lvalue-to-rvalue conversion here for class types,
3455 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3456 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3457 regions. */
3458
3459 arg2 = force_rvalue (arg2);
3460 if (!CLASS_TYPE_P (arg2_type))
3461 arg2_type = TREE_TYPE (arg2);
3462
3463 arg3 = force_rvalue (arg3);
3464 if (!CLASS_TYPE_P (arg2_type))
3465 arg3_type = TREE_TYPE (arg3);
3466
3467 if (arg2 == error_mark_node || arg3 == error_mark_node)
3468 return error_mark_node;
3469
3470 /* [expr.cond]
3471
3472 After those conversions, one of the following shall hold:
3473
3474 --The second and third operands have the same type; the result is of
3475 that type. */
3476 if (same_type_p (arg2_type, arg3_type))
3477 result_type = arg2_type;
3478 /* [expr.cond]
3479
3480 --The second and third operands have arithmetic or enumeration
3481 type; the usual arithmetic conversions are performed to bring
3482 them to a common type, and the result is of that type. */
3483 else if ((ARITHMETIC_TYPE_P (arg2_type)
3484 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3485 && (ARITHMETIC_TYPE_P (arg3_type)
3486 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3487 {
3488 /* In this case, there is always a common type. */
3489 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3490 arg3_type);
3491
3492 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3493 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3494 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3495 arg2_type, arg3_type);
3496 else if (extra_warnings
3497 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3498 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3499 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3500 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3501 warning (0, "enumeral and non-enumeral type in conditional expression");
3502
3503 arg2 = perform_implicit_conversion (result_type, arg2);
3504 arg3 = perform_implicit_conversion (result_type, arg3);
3505 }
3506 /* [expr.cond]
3507
3508 --The second and third operands have pointer type, or one has
3509 pointer type and the other is a null pointer constant; pointer
3510 conversions (_conv.ptr_) and qualification conversions
3511 (_conv.qual_) are performed to bring them to their composite
3512 pointer type (_expr.rel_). The result is of the composite
3513 pointer type.
3514
3515 --The second and third operands have pointer to member type, or
3516 one has pointer to member type and the other is a null pointer
3517 constant; pointer to member conversions (_conv.mem_) and
3518 qualification conversions (_conv.qual_) are performed to bring
3519 them to a common type, whose cv-qualification shall match the
3520 cv-qualification of either the second or the third operand.
3521 The result is of the common type. */
3522 else if ((null_ptr_cst_p (arg2)
3523 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3524 || (null_ptr_cst_p (arg3)
3525 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3526 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3527 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3528 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3529 {
3530 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3531 arg3, "conditional expression");
3532 if (result_type == error_mark_node)
3533 return error_mark_node;
3534 arg2 = perform_implicit_conversion (result_type, arg2);
3535 arg3 = perform_implicit_conversion (result_type, arg3);
3536 }
3537
3538 if (!result_type)
3539 {
3540 error ("operands to ?: have different types %qT and %qT",
3541 arg2_type, arg3_type);
3542 return error_mark_node;
3543 }
3544
3545 valid_operands:
3546 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3547 arg2, arg3));
3548 /* We can't use result_type below, as fold might have returned a
3549 throw_expr. */
3550
3551 if (!lvalue_p)
3552 {
3553 /* Expand both sides into the same slot, hopefully the target of
3554 the ?: expression. We used to check for TARGET_EXPRs here,
3555 but now we sometimes wrap them in NOP_EXPRs so the test would
3556 fail. */
3557 if (CLASS_TYPE_P (TREE_TYPE (result)))
3558 result = get_target_expr (result);
3559 /* If this expression is an rvalue, but might be mistaken for an
3560 lvalue, we must add a NON_LVALUE_EXPR. */
3561 result = rvalue (result);
3562 }
3563
3564 return result;
3565}
3566
3567/* OPERAND is an operand to an expression. Perform necessary steps
3568 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3569 returned. */
3570
3571static tree
3572prep_operand (tree operand)
3573{
3574 if (operand)
3575 {
3576 if (CLASS_TYPE_P (TREE_TYPE (operand))
3577 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3578 /* Make sure the template type is instantiated now. */
3579 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3580 }
3581
3582 return operand;
3583}
3584
3585/* Add each of the viable functions in FNS (a FUNCTION_DECL or
3586 OVERLOAD) to the CANDIDATES, returning an updated list of
3587 CANDIDATES. The ARGS are the arguments provided to the call,
3588 without any implicit object parameter. The EXPLICIT_TARGS are
3589 explicit template arguments provided. TEMPLATE_ONLY is true if
3590 only template functions should be considered. CONVERSION_PATH,
3591 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3592
3593static void
3594add_candidates (tree fns, tree args,
3595 tree explicit_targs, bool template_only,
3596 tree conversion_path, tree access_path,
3597 int flags,
3598 struct z_candidate **candidates)
3599{
3600 tree ctype;
3601 tree non_static_args;
3602
3603 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3604 /* Delay creating the implicit this parameter until it is needed. */
3605 non_static_args = NULL_TREE;
3606
3607 while (fns)
3608 {
3609 tree fn;
3610 tree fn_args;
3611
3612 fn = OVL_CURRENT (fns);
3613 /* Figure out which set of arguments to use. */
3614 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3615 {
3616 /* If this function is a non-static member, prepend the implicit
3617 object parameter. */
3618 if (!non_static_args)
3619 non_static_args = tree_cons (NULL_TREE,
3620 build_this (TREE_VALUE (args)),
3621 TREE_CHAIN (args));
3622 fn_args = non_static_args;
3623 }
3624 else
3625 /* Otherwise, just use the list of arguments provided. */
3626 fn_args = args;
3627
3628 if (TREE_CODE (fn) == TEMPLATE_DECL)
3629 add_template_candidate (candidates,
3630 fn,
3631 ctype,
3632 explicit_targs,
3633 fn_args,
3634 NULL_TREE,
3635 access_path,
3636 conversion_path,
3637 flags,
3638 DEDUCE_CALL);
3639 else if (!template_only)
3640 add_function_candidate (candidates,
3641 fn,
3642 ctype,
3643 fn_args,
3644 access_path,
3645 conversion_path,
3646 flags);
3647 fns = OVL_NEXT (fns);
3648 }
3649}
3650
3651tree
3652build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3653 bool *overloaded_p)
3654{
3655 struct z_candidate *candidates = 0, *cand;
3656 tree arglist, fnname;
3657 tree args[3];
3658 tree result = NULL_TREE;
3659 bool result_valid_p = false;
3660 enum tree_code code2 = NOP_EXPR;
3661 conversion *conv;
3662 void *p;
3663 bool strict_p;
3664 bool any_viable_p;
3665
3666 if (error_operand_p (arg1)
3667 || error_operand_p (arg2)
3668 || error_operand_p (arg3))
3669 return error_mark_node;
3670
3671 if (code == MODIFY_EXPR)
3672 {
3673 code2 = TREE_CODE (arg3);
3674 arg3 = NULL_TREE;
3675 fnname = ansi_assopname (code2);
3676 }
3677 else
3678 fnname = ansi_opname (code);
3679
3680 arg1 = prep_operand (arg1);
3681
3682 switch (code)
3683 {
3684 case NEW_EXPR:
3685 case VEC_NEW_EXPR:
3686 case VEC_DELETE_EXPR:
3687 case DELETE_EXPR:
3688 /* Use build_op_new_call and build_op_delete_call instead. */
3689 gcc_unreachable ();
3690
3691 case CALL_EXPR:
3692 return build_object_call (arg1, arg2);
3693
3694 default:
3695 break;
3696 }
3697
3698 arg2 = prep_operand (arg2);
3699 arg3 = prep_operand (arg3);
3700
3701 if (code == COND_EXPR)
3702 {
3703 if (arg2 == NULL_TREE
3704 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3705 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3706 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3707 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3708 goto builtin;
3709 }
3710 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3711 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3712 goto builtin;
3713
3714 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3715 arg2 = integer_zero_node;
3716
3717 arglist = NULL_TREE;
3718 if (arg3)
3719 arglist = tree_cons (NULL_TREE, arg3, arglist);
3720 if (arg2)
3721 arglist = tree_cons (NULL_TREE, arg2, arglist);
3722 arglist = tree_cons (NULL_TREE, arg1, arglist);
3723
3724 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3725 p = conversion_obstack_alloc (0);
3726
3727 /* Add namespace-scope operators to the list of functions to
3728 consider. */
3729 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3730 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3731 flags, &candidates);
3732 /* Add class-member operators to the candidate set. */
3733 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3734 {
3735 tree fns;
3736
3737 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3738 if (fns == error_mark_node)
3739 {
3740 result = error_mark_node;
3741 goto user_defined_result_ready;
3742 }
3743 if (fns)
3744 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3745 NULL_TREE, false,
3746 BASELINK_BINFO (fns),
3747 TYPE_BINFO (TREE_TYPE (arg1)),
3748 flags, &candidates);
3749 }
3750
3751 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3752 to know about two args; a builtin candidate will always have a first
3753 parameter of type bool. We'll handle that in
3754 build_builtin_candidate. */
3755 if (code == COND_EXPR)
3756 {
3757 args[0] = arg2;
3758 args[1] = arg3;
3759 args[2] = arg1;
3760 }
3761 else
3762 {
3763 args[0] = arg1;
3764 args[1] = arg2;
3765 args[2] = NULL_TREE;
3766 }
3767
3768 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3769
3770 switch (code)
3771 {
3772 case COMPOUND_EXPR:
3773 case ADDR_EXPR:
3774 /* For these, the built-in candidates set is empty
3775 [over.match.oper]/3. We don't want non-strict matches
3776 because exact matches are always possible with built-in
3777 operators. The built-in candidate set for COMPONENT_REF
3778 would be empty too, but since there are no such built-in
3779 operators, we accept non-strict matches for them. */
3780 strict_p = true;
3781 break;
3782
3783 default:
3784 strict_p = pedantic;
3785 break;
3786 }
3787
3788 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3789 if (!any_viable_p)
3790 {
3791 switch (code)
3792 {
3793 case POSTINCREMENT_EXPR:
3794 case POSTDECREMENT_EXPR:
3795 /* Look for an `operator++ (int)'. If they didn't have
3796 one, then we fall back to the old way of doing things. */
3797 if (flags & LOOKUP_COMPLAIN)
3798 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3799 "trying prefix operator instead",
3800 fnname,
3801 operator_name_info[code].name);
3802 if (code == POSTINCREMENT_EXPR)
3803 code = PREINCREMENT_EXPR;
3804 else
3805 code = PREDECREMENT_EXPR;
3806 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3807 overloaded_p);
3808 break;
3809
3810 /* The caller will deal with these. */
3811 case ADDR_EXPR:
3812 case COMPOUND_EXPR:
3813 case COMPONENT_REF:
3814 result = NULL_TREE;
3815 result_valid_p = true;
3816 break;
3817
3818 default:
3819 if (flags & LOOKUP_COMPLAIN)
3820 {
3821 op_error (code, code2, arg1, arg2, arg3, "no match");
3822 print_z_candidates (candidates);
3823 }
3824 result = error_mark_node;
3825 break;
3826 }
3827 }
3828 else
3829 {
3830 cand = tourney (candidates);
3831 if (cand == 0)
3832 {
3833 if (flags & LOOKUP_COMPLAIN)
3834 {
3835 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3836 print_z_candidates (candidates);
3837 }
3838 result = error_mark_node;
3839 }
3840 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3841 {
3842 if (overloaded_p)
3843 *overloaded_p = true;
3844
3845 result = build_over_call (cand, LOOKUP_NORMAL);
3846 }
3847 else
3848 {
3849 /* Give any warnings we noticed during overload resolution. */
3850 if (cand->warnings)
3851 {
3852 struct candidate_warning *w;
3853 for (w = cand->warnings; w; w = w->next)
3854 joust (cand, w->loser, 1);
3855 }
3856
3857 /* Check for comparison of different enum types. */
3858 switch (code)
3859 {
3860 case GT_EXPR:
3861 case LT_EXPR:
3862 case GE_EXPR:
3863 case LE_EXPR:
3864 case EQ_EXPR:
3865 case NE_EXPR:
3866 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3867 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3868 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3869 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3870 {
3871 warning (0, "comparison between %q#T and %q#T",
3872 TREE_TYPE (arg1), TREE_TYPE (arg2));
3873 }
3874 break;
3875 default:
3876 break;
3877 }
3878
3879 /* We need to strip any leading REF_BIND so that bitfields
3880 don't cause errors. This should not remove any important
3881 conversions, because builtins don't apply to class
3882 objects directly. */
3883 conv = cand->convs[0];
3884 if (conv->kind == ck_ref_bind)
3885 conv = conv->u.next;
3886 arg1 = convert_like (conv, arg1);
3887 if (arg2)
3888 {
3889 conv = cand->convs[1];
3890 if (conv->kind == ck_ref_bind)
3891 conv = conv->u.next;
3892 arg2 = convert_like (conv, arg2);
3893 }
3894 if (arg3)
3895 {
3896 conv = cand->convs[2];
3897 if (conv->kind == ck_ref_bind)
3898 conv = conv->u.next;
3899 arg3 = convert_like (conv, arg3);
3900 }
3901 }
3902 }
3903
3904 user_defined_result_ready:
3905
3906 /* Free all the conversions we allocated. */
3907 obstack_free (&conversion_obstack, p);
3908
3909 if (result || result_valid_p)
3910 return result;
3911
3912 builtin:
3913 switch (code)
3914 {
3915 case MODIFY_EXPR:
3916 return build_modify_expr (arg1, code2, arg2);
3917
3918 case INDIRECT_REF:
3919 return build_indirect_ref (arg1, "unary *");
3920
3921 case PLUS_EXPR:
3922 case MINUS_EXPR:
3923 case MULT_EXPR:
3924 case TRUNC_DIV_EXPR:
3925 case GT_EXPR:
3926 case LT_EXPR:
3927 case GE_EXPR:
3928 case LE_EXPR:
3929 case EQ_EXPR:
3930 case NE_EXPR:
3931 case MAX_EXPR:
3932 case MIN_EXPR:
3933 case LSHIFT_EXPR:
3934 case RSHIFT_EXPR:
3935 case TRUNC_MOD_EXPR:
3936 case BIT_AND_EXPR:
3937 case BIT_IOR_EXPR:
3938 case BIT_XOR_EXPR:
3939 case TRUTH_ANDIF_EXPR:
3940 case TRUTH_ORIF_EXPR:
3941 return cp_build_binary_op (code, arg1, arg2);
3942
3943 case UNARY_PLUS_EXPR:
3944 case NEGATE_EXPR:
3945 case BIT_NOT_EXPR:
3946 case TRUTH_NOT_EXPR:
3947 case PREINCREMENT_EXPR:
3948 case POSTINCREMENT_EXPR:
3949 case PREDECREMENT_EXPR:
3950 case POSTDECREMENT_EXPR:
3951 case REALPART_EXPR:
3952 case IMAGPART_EXPR:
3953 return build_unary_op (code, arg1, candidates != 0);
3954
3955 case ARRAY_REF:
3956 return build_array_ref (arg1, arg2);
3957
3958 case COND_EXPR:
3959 return build_conditional_expr (arg1, arg2, arg3);
3960
3961 case MEMBER_REF:
3962 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3963
3964 /* The caller will deal with these. */
3965 case ADDR_EXPR:
3966 case COMPONENT_REF:
3967 case COMPOUND_EXPR:
3968 return NULL_TREE;
3969
3970 default:
3971 gcc_unreachable ();
3972 }
3973 return NULL_TREE;
3974}
3975
3976/* Build a call to operator delete. This has to be handled very specially,
3977 because the restrictions on what signatures match are different from all
3978 other call instances. For a normal delete, only a delete taking (void *)
3979 or (void *, size_t) is accepted. For a placement delete, only an exact
3980 match with the placement new is accepted.
3981
3982 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3983 ADDR is the pointer to be deleted.
3984 SIZE is the size of the memory block to be deleted.
3985 GLOBAL_P is true if the delete-expression should not consider
3986 class-specific delete operators.
3987 PLACEMENT is the corresponding placement new call, or NULL_TREE.
3988
3989 If this call to "operator delete" is being generated as part to
3990 deallocate memory allocated via a new-expression (as per [expr.new]
3991 which requires that if the initialization throws an exception then
3992 we call a deallocation function), then ALLOC_FN is the allocation
3993 function. */
3994
3995tree
3996build_op_delete_call (enum tree_code code, tree addr, tree size,
3997 bool global_p, tree placement,
3998 tree alloc_fn)
3999{
4000 tree fn = NULL_TREE;
4001 tree fns, fnname, argtypes, args, type;
4002 int pass;
4003
4004 if (addr == error_mark_node)
4005 return error_mark_node;
4006
4007 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4008
4009 fnname = ansi_opname (code);
4010
4011 if (CLASS_TYPE_P (type)
4012 && COMPLETE_TYPE_P (complete_type (type))
4013 && !global_p)
4014 /* In [class.free]
4015
4016 If the result of the lookup is ambiguous or inaccessible, or if
4017 the lookup selects a placement deallocation function, the
4018 program is ill-formed.
4019
4020 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4021 {
4022 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4023 if (fns == error_mark_node)
4024 return error_mark_node;
4025 }
4026 else
4027 fns = NULL_TREE;
4028
4029 if (fns == NULL_TREE)
4030 fns = lookup_name_nonclass (fnname);
4031
4032 if (placement)
4033 {
4034 /* Get the parameter types for the allocation function that is
4035 being called. */
4036 gcc_assert (alloc_fn != NULL_TREE);
4037 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4038 /* Also the second argument. */
4039 args = TREE_CHAIN (TREE_OPERAND (placement, 1));
4040 }
4041 else
4042 {
4043 /* First try it without the size argument. */
4044 argtypes = void_list_node;
4045 args = NULL_TREE;
4046 }
4047
4048 /* Strip const and volatile from addr. */
4049 addr = cp_convert (ptr_type_node, addr);
4050
4051 /* We make two tries at finding a matching `operator delete'. On
4052 the first pass, we look for a one-operator (or placement)
4053 operator delete. If we're not doing placement delete, then on
4054 the second pass we look for a two-argument delete. */
4055 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4056 {
4057 /* Go through the `operator delete' functions looking for one
4058 with a matching type. */
4059 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4060 fn;
4061 fn = OVL_NEXT (fn))
4062 {
4063 tree t;
4064
4065 /* The first argument must be "void *". */
4066 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4067 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4068 continue;
4069 t = TREE_CHAIN (t);
4070 /* On the first pass, check the rest of the arguments. */
4071 if (pass == 0)
4072 {
4073 tree a = argtypes;
4074 while (a && t)
4075 {
4076 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4077 break;
4078 a = TREE_CHAIN (a);
4079 t = TREE_CHAIN (t);
4080 }
4081 if (!a && !t)
4082 break;
4083 }
4084 /* On the second pass, look for a function with exactly two
4085 arguments: "void *" and "size_t". */
4086 else if (pass == 1
4087 /* For "operator delete(void *, ...)" there will be
4088 no second argument, but we will not get an exact
4089 match above. */
4090 && t
4091 && same_type_p (TREE_VALUE (t), sizetype)
4092 && TREE_CHAIN (t) == void_list_node)
4093 break;
4094 }
4095
4096 /* If we found a match, we're done. */
4097 if (fn)
4098 break;
4099 }
4100
4101 /* If we have a matching function, call it. */
4102 if (fn)
4103 {
4104 /* Make sure we have the actual function, and not an
4105 OVERLOAD. */
4106 fn = OVL_CURRENT (fn);
4107
4108 /* If the FN is a member function, make sure that it is
4109 accessible. */
4110 if (DECL_CLASS_SCOPE_P (fn))
4111 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4112
4113 if (pass == 0)
4114 args = tree_cons (NULL_TREE, addr, args);
4115 else
4116 args = tree_cons (NULL_TREE, addr,
4117 build_tree_list (NULL_TREE, size));
4118
4119 if (placement)
4120 {
4121 /* The placement args might not be suitable for overload
4122 resolution at this point, so build the call directly. */
4123 mark_used (fn);
4124 return build_cxx_call (fn, args);
4125 }
4126 else
4127 return build_function_call (fn, args);
4128 }
4129
4130 /* [expr.new]
4131
4132 If no unambiguous matching deallocation function can be found,
4133 propagating the exception does not cause the object's memory to
4134 be freed. */
4135 if (alloc_fn)
4136 {
4137 if (!placement)
4138 warning (0, "no corresponding deallocation function for `%D'",
4139 alloc_fn);
4140 return NULL_TREE;
4141 }
4142
4143 error ("no suitable %<operator %s%> for %qT",
4144 operator_name_info[(int)code].name, type);
4145 return error_mark_node;
4146}
4147
4148/* If the current scope isn't allowed to access DECL along
4149 BASETYPE_PATH, give an error. The most derived class in
4150 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4151 the declaration to use in the error diagnostic. */
4152
4153bool
4154enforce_access (tree basetype_path, tree decl, tree diag_decl)
4155{
4156 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4157
4158 if (!accessible_p (basetype_path, decl, true))
4159 {
4160 if (TREE_PRIVATE (decl))
4161 error ("%q+#D is private", diag_decl);
4162 else if (TREE_PROTECTED (decl))
4163 error ("%q+#D is protected", diag_decl);
4164 else
4165 error ("%q+#D is inaccessible", diag_decl);
4166 error ("within this context");
4167 return false;
4168 }
4169
4170 return true;
4171}
4172
4173/* Check that a callable constructor to initialize a temporary of
4174 TYPE from an EXPR exists. */
4175
4176static void
4177check_constructor_callable (tree type, tree expr)
4178{
4179 build_special_member_call (NULL_TREE,
4180 complete_ctor_identifier,
4181 build_tree_list (NULL_TREE, expr),
4182 type,
4183 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4184 | LOOKUP_NO_CONVERSION
4185 | LOOKUP_CONSTRUCTOR_CALLABLE);
4186}
4187
4188/* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4189 bitwise or of LOOKUP_* values. If any errors are warnings are
4190 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4191 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4192 to NULL. */
4193
4194static tree
4195build_temp (tree expr, tree type, int flags,
4196 diagnostic_fn_t *diagnostic_fn)
4197{
4198 int savew, savee;
4199
4200 savew = warningcount, savee = errorcount;
4201 expr = build_special_member_call (NULL_TREE,
4202 complete_ctor_identifier,
4203 build_tree_list (NULL_TREE, expr),
4204 type, flags);
4205 if (warningcount > savew)
4206 *diagnostic_fn = warning0;
4207 else if (errorcount > savee)
4208 *diagnostic_fn = error;
4209 else
4210 *diagnostic_fn = NULL;
4211 return expr;
4212}
4213
4214
4215/* Perform the conversions in CONVS on the expression EXPR. FN and
4216 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4217 indicates the `this' argument of a method. INNER is nonzero when
4218 being called to continue a conversion chain. It is negative when a
4219 reference binding will be applied, positive otherwise. If
4220 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4221 conversions will be emitted if appropriate. If C_CAST_P is true,
4222 this conversion is coming from a C-style cast; in that case,
4223 conversions to inaccessible bases are permitted. */
4224
4225static tree
4226convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4227 int inner, bool issue_conversion_warnings,
4228 bool c_cast_p)
4229{
4230 tree totype = convs->type;
4231 diagnostic_fn_t diagnostic_fn;
4232
4233 if (convs->bad_p
4234 && convs->kind != ck_user
4235 && convs->kind != ck_ambig
4236 && convs->kind != ck_ref_bind)
4237 {
4238 conversion *t = convs;
4239 for (; t; t = convs->u.next)
4240 {
4241 if (t->kind == ck_user || !t->bad_p)
4242 {
4243 expr = convert_like_real (t, expr, fn, argnum, 1,
4244 /*issue_conversion_warnings=*/false,
4245 /*c_cast_p=*/false);
4246 break;
4247 }
4248 else if (t->kind == ck_ambig)
4249 return convert_like_real (t, expr, fn, argnum, 1,
4250 /*issue_conversion_warnings=*/false,
4251 /*c_cast_p=*/false);
4252 else if (t->kind == ck_identity)
4253 break;
4254 }
4255 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4256 if (fn)
4257 pedwarn (" initializing argument %P of %qD", argnum, fn);
4258 return cp_convert (totype, expr);
4259 }
4260
4261 if (issue_conversion_warnings)
4262 {
4263 tree t = non_reference (totype);
4264
4265 /* Issue warnings about peculiar, but valid, uses of NULL. */
4266 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4267 {
4268 if (fn)
4269 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4270 argnum, fn);
4271 else
4272 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4273 }
4274
4275 /* Warn about assigning a floating-point type to an integer type. */
4276 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4277 && TREE_CODE (t) == INTEGER_TYPE)
4278 {
4279 if (fn)
4280 warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4281 TREE_TYPE (expr), argnum, fn);
4282 else
4283 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4284 }
4285 }
4286
4287 switch (convs->kind)
4288 {
4289 case ck_user:
4290 {
4291 struct z_candidate *cand = convs->cand;
4292 tree convfn = cand->fn;
4293 tree args;
4294
4295 if (DECL_CONSTRUCTOR_P (convfn))
4296 {
4297 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4298 0);
4299
4300 args = build_tree_list (NULL_TREE, expr);
4301 /* We should never try to call the abstract or base constructor
4302 from here. */
4303 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4304 && !DECL_HAS_VTT_PARM_P (convfn));
4305 args = tree_cons (NULL_TREE, t, args);
4306 }
4307 else
4308 args = build_this (expr);
4309 expr = build_over_call (cand, LOOKUP_NORMAL);
4310
4311 /* If this is a constructor or a function returning an aggr type,
4312 we need to build up a TARGET_EXPR. */
4313 if (DECL_CONSTRUCTOR_P (convfn))
4314 expr = build_cplus_new (totype, expr);
4315
4316 /* The result of the call is then used to direct-initialize the object
4317 that is the destination of the copy-initialization. [dcl.init]
4318
4319 Note that this step is not reflected in the conversion sequence;
4320 it affects the semantics when we actually perform the
4321 conversion, but is not considered during overload resolution.
4322
4323 If the target is a class, that means call a ctor. */
4324 if (IS_AGGR_TYPE (totype)
4325 && (inner >= 0 || !lvalue_p (expr)))
4326 {
4327 expr = (build_temp
4328 (expr, totype,
4329 /* Core issue 84, now a DR, says that we don't
4330 allow UDCs for these args (which deliberately
4331 breaks copy-init of an auto_ptr<Base> from an
4332 auto_ptr<Derived>). */
4333 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4334 &diagnostic_fn));
4335
4336 if (diagnostic_fn)
4337 {
4338 if (fn)
4339 diagnostic_fn
4340 (" initializing argument %P of %qD from result of %qD",
4341 argnum, fn, convfn);
4342 else
4343 diagnostic_fn
4344 (" initializing temporary from result of %qD", convfn);
4345 }
4346 expr = build_cplus_new (totype, expr);
4347 }
4348 return expr;
4349 }
4350 case ck_identity:
4351 if (type_unknown_p (expr))
4352 expr = instantiate_type (totype, expr, tf_warning_or_error);
4353 /* Convert a constant to its underlying value, unless we are
4354 about to bind it to a reference, in which case we need to
4355 leave it as an lvalue. */
4356 if (inner >= 0)
4357 expr = decl_constant_value (expr);
4358 if (convs->check_copy_constructor_p)
4359 check_constructor_callable (totype, expr);
4360 return expr;
4361 case ck_ambig:
4362 /* Call build_user_type_conversion again for the error. */
4363 return build_user_type_conversion
4364 (totype, convs->u.expr, LOOKUP_NORMAL);
4365
4366 default:
4367 break;
4368 };
4369
4370 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4371 convs->kind == ck_ref_bind ? -1 : 1,
4372 /*issue_conversion_warnings=*/false,
4373 c_cast_p);
4374 if (expr == error_mark_node)
4375 return error_mark_node;
4376
4377 switch (convs->kind)
4378 {
4379 case ck_rvalue:
4380 expr = convert_bitfield_to_declared_type (expr);
4381 if (! IS_AGGR_TYPE (totype))
4382 return expr;
4383 /* Else fall through. */
4384 case ck_base:
4385 if (convs->kind == ck_base && !convs->need_temporary_p)
4386 {
4387 /* We are going to bind a reference directly to a base-class
4388 subobject of EXPR. */
4389 if (convs->check_copy_constructor_p)
4390 check_constructor_callable (TREE_TYPE (expr), expr);
4391 /* Build an expression for `*((base*) &expr)'. */
4392 expr = build_unary_op (ADDR_EXPR, expr, 0);
4393 expr = convert_to_base (expr, build_pointer_type (totype),
4394 !c_cast_p, /*nonnull=*/true);
4395 expr = build_indirect_ref (expr, "implicit conversion");
4396 return expr;
4397 }
4398
4399 /* Copy-initialization where the cv-unqualified version of the source
4400 type is the same class as, or a derived class of, the class of the
4401 destination [is treated as direct-initialization]. [dcl.init] */
4402 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4403 &diagnostic_fn);
4404 if (diagnostic_fn && fn)
4405 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4406 return build_cplus_new (totype, expr);
4407
4408 case ck_ref_bind:
4409 {
4410 tree ref_type = totype;
4411
4412 /* If necessary, create a temporary. */
4413 if (convs->need_temporary_p || !lvalue_p (expr))
4414 {
4415 tree type = convs->u.next->type;
4416 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4417
4418 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4419 {
4420 /* If the reference is volatile or non-const, we
4421 cannot create a temporary. */
4422 if (lvalue & clk_bitfield)
4423 error ("cannot bind bitfield %qE to %qT",
4424 expr, ref_type);
4425 else if (lvalue & clk_packed)
4426 error ("cannot bind packed field %qE to %qT",
4427 expr, ref_type);
4428 else
4429 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4430 return error_mark_node;
4431 }
4432 /* If the source is a packed field, and we must use a copy
4433 constructor, then building the target expr will require
4434 binding the field to the reference parameter to the
4435 copy constructor, and we'll end up with an infinite
4436 loop. If we can use a bitwise copy, then we'll be
4437 OK. */
4438 if ((lvalue & clk_packed)
4439 && CLASS_TYPE_P (type)
4440 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4441 {
4442 error ("cannot bind packed field %qE to %qT",
4443 expr, ref_type);
4444 return error_mark_node;
4445 }
4446 expr = build_target_expr_with_type (expr, type);
4447 }
4448
4449 /* Take the address of the thing to which we will bind the
4450 reference. */
4451 expr = build_unary_op (ADDR_EXPR, expr, 1);
4452 if (expr == error_mark_node)
4453 return error_mark_node;
4454
4455 /* Convert it to a pointer to the type referred to by the
4456 reference. This will adjust the pointer if a derived to
4457 base conversion is being performed. */
4458 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4459 expr);
4460 /* Convert the pointer to the desired reference type. */
4461 return build_nop (ref_type, expr);
4462 }
4463
4464 case ck_lvalue:
4465 return decay_conversion (expr);
4466
4467 case ck_qual:
4468 /* Warn about deprecated conversion if appropriate. */
4469 string_conv_p (totype, expr, 1);
4470 break;
4471
4472 case ck_ptr:
4473 if (convs->base_p)
4474 expr = convert_to_base (expr, totype, !c_cast_p,
4475 /*nonnull=*/false);
4476 return build_nop (totype, expr);
4477
4478 case ck_pmem:
4479 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4480 c_cast_p);
4481
4482 default:
4483 break;
4484 }
4485
4486 if (issue_conversion_warnings)
4487 expr = convert_and_check (totype, expr);
4488 else
4489 expr = convert (totype, expr);
4490
4491 return expr;
4492}
4493
4494/* Build a call to __builtin_trap. */
4495
4496static tree
4497call_builtin_trap (void)
4498{
4499 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4500
4501 gcc_assert (fn != NULL);
4502 fn = build_call (fn, NULL_TREE);
4503 return fn;
4504}
4505
4506/* ARG is being passed to a varargs function. Perform any conversions
4507 required. Return the converted value. */
4508
4509tree
4510convert_arg_to_ellipsis (tree arg)
4511{
4512 /* [expr.call]
4513
4514 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4515 standard conversions are performed. */
4516 arg = decay_conversion (arg);
4517 /* [expr.call]
4518
4519 If the argument has integral or enumeration type that is subject
4520 to the integral promotions (_conv.prom_), or a floating point
4521 type that is subject to the floating point promotion
4522 (_conv.fpprom_), the value of the argument is converted to the
4523 promoted type before the call. */
4524 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4525 && (TYPE_PRECISION (TREE_TYPE (arg))
4526 < TYPE_PRECISION (double_type_node)))
4527 arg = convert_to_real (double_type_node, arg);
4528 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4529 arg = perform_integral_promotions (arg);
4530
4531 arg = require_complete_type (arg);
4532
4533 if (arg != error_mark_node
4534 && !pod_type_p (TREE_TYPE (arg)))
4535 {
4536 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4537 here and do a bitwise copy, but now cp_expr_size will abort if we
4538 try to do that.
4539 If the call appears in the context of a sizeof expression,
4540 there is no need to emit a warning, since the expression won't be
4541 evaluated. We keep the builtin_trap just as a safety check. */
4542 if (!skip_evaluation)
4543 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4544 "call will abort at runtime", TREE_TYPE (arg));
4545 arg = call_builtin_trap ();
4546 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4547 integer_zero_node);
4548 }
4549
4550 return arg;
4551}
4552
4553/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4554
4555tree
4556build_x_va_arg (tree expr, tree type)
4557{
4558 if (processing_template_decl)
4559 return build_min (VA_ARG_EXPR, type, expr);
4560
4561 type = complete_type_or_else (type, NULL_TREE);
4562
4563 if (expr == error_mark_node || !type)
4564 return error_mark_node;
4565
4566 if (! pod_type_p (type))
4567 {
4568 /* Remove reference types so we don't ICE later on. */
4569 tree type1 = non_reference (type);
4570 /* Undefined behavior [expr.call] 5.2.2/7. */
4571 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4572 "call will abort at runtime", type);
4573 expr = convert (build_pointer_type (type1), null_node);
4574 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4575 call_builtin_trap (), expr);
4576 expr = build_indirect_ref (expr, NULL);
4577 return expr;
4578 }
4579
4580 return build_va_arg (expr, type);
4581}
4582
4583/* TYPE has been given to va_arg. Apply the default conversions which
4584 would have happened when passed via ellipsis. Return the promoted
4585 type, or the passed type if there is no change. */
4586
4587tree
4588cxx_type_promotes_to (tree type)
4589{
4590 tree promote;
4591
4592 /* Perform the array-to-pointer and function-to-pointer
4593 conversions. */
4594 type = type_decays_to (type);
4595
4596 promote = type_promotes_to (type);
4597 if (same_type_p (type, promote))
4598 promote = type;
4599
4600 return promote;
4601}
4602
4603/* ARG is a default argument expression being passed to a parameter of
4604 the indicated TYPE, which is a parameter to FN. Do any required
4605 conversions. Return the converted value. */
4606
4607tree
4608convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4609{
4610 /* If the ARG is an unparsed default argument expression, the
4611 conversion cannot be performed. */
4612 if (TREE_CODE (arg) == DEFAULT_ARG)
4613 {
4614 error ("the default argument for parameter %d of %qD has "
4615 "not yet been parsed",
4616 parmnum, fn);
4617 return error_mark_node;
4618 }
4619
4620 if (fn && DECL_TEMPLATE_INFO (fn))
4621 arg = tsubst_default_argument (fn, type, arg);
4622
4623 arg = break_out_target_exprs (arg);
4624
4625 if (TREE_CODE (arg) == CONSTRUCTOR)
4626 {
4627 arg = digest_init (type, arg);
4628 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4629 "default argument", fn, parmnum);
4630 }
4631 else
4632 {
4633 /* We must make a copy of ARG, in case subsequent processing
4634 alters any part of it. For example, during gimplification a
4635 cast of the form (T) &X::f (where "f" is a member function)
4636 will lead to replacing the PTRMEM_CST for &X::f with a
4637 VAR_DECL. We can avoid the copy for constants, since they
4638 are never modified in place. */
4639 if (!CONSTANT_CLASS_P (arg))
4640 arg = unshare_expr (arg);
4641 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4642 "default argument", fn, parmnum);
4643 arg = convert_for_arg_passing (type, arg);
4644 }
4645
4646 return arg;
4647}
4648
4649/* Returns the type which will really be used for passing an argument of
4650 type TYPE. */
4651
4652tree
4653type_passed_as (tree type)
4654{
4655 /* Pass classes with copy ctors by invisible reference. */
4656 if (TREE_ADDRESSABLE (type))
4657 {
4658 type = build_reference_type (type);
4659 /* There are no other pointers to this temporary. */
4660 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4661 }
4662 else if (targetm.calls.promote_prototypes (type)
4663 && INTEGRAL_TYPE_P (type)
4664 && COMPLETE_TYPE_P (type)
4665 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4666 TYPE_SIZE (integer_type_node)))
4667 type = integer_type_node;
4668
4669 return type;
4670}
4671
4672/* Actually perform the appropriate conversion. */
4673
4674tree
4675convert_for_arg_passing (tree type, tree val)
4676{
| 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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) and
5 modified by Brendan Kehoe (brendan@cygnus.com).
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GCC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING. If not, write to
21the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22Boston, MA 02110-1301, USA. */
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
43/* The various kinds of conversion. */
44
45typedef enum conversion_kind {
46 ck_identity,
47 ck_lvalue,
48 ck_qual,
49 ck_std,
50 ck_ptr,
51 ck_pmem,
52 ck_base,
53 ck_ref_bind,
54 ck_user,
55 ck_ambig,
56 ck_rvalue
57} conversion_kind;
58
59/* The rank of the conversion. Order of the enumerals matters; better
60 conversions should come earlier in the list. */
61
62typedef enum conversion_rank {
63 cr_identity,
64 cr_exact,
65 cr_promotion,
66 cr_std,
67 cr_pbool,
68 cr_user,
69 cr_ellipsis,
70 cr_bad
71} conversion_rank;
72
73/* An implicit conversion sequence, in the sense of [over.best.ics].
74 The first conversion to be performed is at the end of the chain.
75 That conversion is always a cr_identity conversion. */
76
77typedef struct conversion conversion;
78struct conversion {
79 /* The kind of conversion represented by this step. */
80 conversion_kind kind;
81 /* The rank of this conversion. */
82 conversion_rank rank;
83 BOOL_BITFIELD user_conv_p : 1;
84 BOOL_BITFIELD ellipsis_p : 1;
85 BOOL_BITFIELD this_p : 1;
86 BOOL_BITFIELD bad_p : 1;
87 /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a
88 temporary should be created to hold the result of the
89 conversion. */
90 BOOL_BITFIELD need_temporary_p : 1;
91 /* If KIND is ck_identity or ck_base_conv, true to indicate that the
92 copy constructor must be accessible, even though it is not being
93 used. */
94 BOOL_BITFIELD check_copy_constructor_p : 1;
95 /* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
96 from a pointer-to-derived to pointer-to-base is being performed. */
97 BOOL_BITFIELD base_p : 1;
98 /* The type of the expression resulting from the conversion. */
99 tree type;
100 union {
101 /* The next conversion in the chain. Since the conversions are
102 arranged from outermost to innermost, the NEXT conversion will
103 actually be performed before this conversion. This variant is
104 used only when KIND is neither ck_identity nor ck_ambig. */
105 conversion *next;
106 /* The expression at the beginning of the conversion chain. This
107 variant is used only if KIND is ck_identity or ck_ambig. */
108 tree expr;
109 } u;
110 /* The function candidate corresponding to this conversion
111 sequence. This field is only used if KIND is ck_user. */
112 struct z_candidate *cand;
113};
114
115#define CONVERSION_RANK(NODE) \
116 ((NODE)->bad_p ? cr_bad \
117 : (NODE)->ellipsis_p ? cr_ellipsis \
118 : (NODE)->user_conv_p ? cr_user \
119 : (NODE)->rank)
120
121static struct obstack conversion_obstack;
122static bool conversion_obstack_initialized;
123
124static struct z_candidate * tourney (struct z_candidate *);
125static int equal_functions (tree, tree);
126static int joust (struct z_candidate *, struct z_candidate *, bool);
127static int compare_ics (conversion *, conversion *);
128static tree build_over_call (struct z_candidate *, int);
129static tree build_java_interface_fn_ref (tree, tree);
130#define convert_like(CONV, EXPR) \
131 convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \
132 /*issue_conversion_warnings=*/true, \
133 /*c_cast_p=*/false)
134#define convert_like_with_context(CONV, EXPR, FN, ARGNO) \
135 convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \
136 /*issue_conversion_warnings=*/true, \
137 /*c_cast_p=*/false)
138static tree convert_like_real (conversion *, tree, tree, int, int, bool,
139 bool);
140static void op_error (enum tree_code, enum tree_code, tree, tree,
141 tree, const char *);
142static tree build_object_call (tree, tree);
143static tree resolve_args (tree);
144static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
145static void print_z_candidate (const char *, struct z_candidate *);
146static void print_z_candidates (struct z_candidate *);
147static tree build_this (tree);
148static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
149static bool any_strictly_viable (struct z_candidate *);
150static struct z_candidate *add_template_candidate
151 (struct z_candidate **, tree, tree, tree, tree, tree,
152 tree, tree, int, unification_kind_t);
153static struct z_candidate *add_template_candidate_real
154 (struct z_candidate **, tree, tree, tree, tree, tree,
155 tree, tree, int, tree, unification_kind_t);
156static struct z_candidate *add_template_conv_candidate
157 (struct z_candidate **, tree, tree, tree, tree, tree, tree);
158static void add_builtin_candidates
159 (struct z_candidate **, enum tree_code, enum tree_code,
160 tree, tree *, int);
161static void add_builtin_candidate
162 (struct z_candidate **, enum tree_code, enum tree_code,
163 tree, tree, tree, tree *, tree *, int);
164static bool is_complete (tree);
165static void build_builtin_candidate
166 (struct z_candidate **, tree, tree, tree, tree *, tree *,
167 int);
168static struct z_candidate *add_conv_candidate
169 (struct z_candidate **, tree, tree, tree, tree, tree);
170static struct z_candidate *add_function_candidate
171 (struct z_candidate **, tree, tree, tree, tree, tree, int);
172static conversion *implicit_conversion (tree, tree, tree, bool, int);
173static conversion *standard_conversion (tree, tree, tree, bool, int);
174static conversion *reference_binding (tree, tree, tree, bool, int);
175static conversion *build_conv (conversion_kind, tree, conversion *);
176static bool is_subseq (conversion *, conversion *);
177static tree maybe_handle_ref_bind (conversion **);
178static void maybe_handle_implicit_object (conversion **);
179static struct z_candidate *add_candidate
180 (struct z_candidate **, tree, tree, size_t,
181 conversion **, tree, tree, int);
182static tree source_type (conversion *);
183static void add_warning (struct z_candidate *, struct z_candidate *);
184static bool reference_related_p (tree, tree);
185static bool reference_compatible_p (tree, tree);
186static conversion *convert_class_to_reference (tree, tree, tree);
187static conversion *direct_reference_binding (tree, conversion *);
188static bool promoted_arithmetic_type_p (tree);
189static conversion *conditional_conversion (tree, tree);
190static char *name_as_c_string (tree, tree, bool *);
191static tree call_builtin_trap (void);
192static tree prep_operand (tree);
193static void add_candidates (tree, tree, tree, bool, tree, tree,
194 int, struct z_candidate **);
195static conversion *merge_conversion_sequences (conversion *, conversion *);
196static bool magic_varargs_p (tree);
197typedef void (*diagnostic_fn_t) (const char *, ...) ATTRIBUTE_GCC_CXXDIAG(1,2);
198static tree build_temp (tree, tree, int, diagnostic_fn_t *);
199static void check_constructor_callable (tree, tree);
200
201/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
202 NAME can take many forms... */
203
204bool
205check_dtor_name (tree basetype, tree name)
206{
207 /* Just accept something we've already complained about. */
208 if (name == error_mark_node)
209 return true;
210
211 if (TREE_CODE (name) == TYPE_DECL)
212 name = TREE_TYPE (name);
213 else if (TYPE_P (name))
214 /* OK */;
215 else if (TREE_CODE (name) == IDENTIFIER_NODE)
216 {
217 if ((IS_AGGR_TYPE (basetype) && name == constructor_name (basetype))
218 || (TREE_CODE (basetype) == ENUMERAL_TYPE
219 && name == TYPE_IDENTIFIER (basetype)))
220 return true;
221 else
222 name = get_type_value (name);
223 }
224 else
225 {
226 /* In the case of:
227
228 template <class T> struct S { ~S(); };
229 int i;
230 i.~S();
231
232 NAME will be a class template. */
233 gcc_assert (DECL_CLASS_TEMPLATE_P (name));
234 return false;
235 }
236
237 if (!name)
238 return false;
239 return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
240}
241
242/* We want the address of a function or method. We avoid creating a
243 pointer-to-member function. */
244
245tree
246build_addr_func (tree function)
247{
248 tree type = TREE_TYPE (function);
249
250 /* We have to do these by hand to avoid real pointer to member
251 functions. */
252 if (TREE_CODE (type) == METHOD_TYPE)
253 {
254 if (TREE_CODE (function) == OFFSET_REF)
255 {
256 tree object = build_address (TREE_OPERAND (function, 0));
257 return get_member_function_from_ptrfunc (&object,
258 TREE_OPERAND (function, 1));
259 }
260 function = build_address (function);
261 }
262 else
263 function = decay_conversion (function);
264
265 return function;
266}
267
268/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
269 POINTER_TYPE to those. Note, pointer to member function types
270 (TYPE_PTRMEMFUNC_P) must be handled by our callers. */
271
272tree
273build_call (tree function, tree parms)
274{
275 int is_constructor = 0;
276 int nothrow;
277 tree tmp;
278 tree decl;
279 tree result_type;
280 tree fntype;
281
282 function = build_addr_func (function);
283
284 gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
285 fntype = TREE_TYPE (TREE_TYPE (function));
286 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
287 || TREE_CODE (fntype) == METHOD_TYPE);
288 result_type = TREE_TYPE (fntype);
289
290 if (TREE_CODE (function) == ADDR_EXPR
291 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
292 {
293 decl = TREE_OPERAND (function, 0);
294 if (!TREE_USED (decl))
295 {
296 /* We invoke build_call directly for several library
297 functions. These may have been declared normally if
298 we're building libgcc, so we can't just check
299 DECL_ARTIFICIAL. */
300 gcc_assert (DECL_ARTIFICIAL (decl)
301 || !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
302 "__", 2));
303 mark_used (decl);
304 }
305 }
306 else
307 decl = NULL_TREE;
308
309 /* We check both the decl and the type; a function may be known not to
310 throw without being declared throw(). */
311 nothrow = ((decl && TREE_NOTHROW (decl))
312 || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (function))));
313
314 if (decl && TREE_THIS_VOLATILE (decl) && cfun)
315 current_function_returns_abnormally = 1;
316
317 if (decl && TREE_DEPRECATED (decl))
318 warn_deprecated_use (decl);
319 require_complete_eh_spec_types (fntype, decl);
320
321 if (decl && DECL_CONSTRUCTOR_P (decl))
322 is_constructor = 1;
323
324 /* Don't pass empty class objects by value. This is useful
325 for tags in STL, which are used to control overload resolution.
326 We don't need to handle other cases of copying empty classes. */
327 if (! decl || ! DECL_BUILT_IN (decl))
328 for (tmp = parms; tmp; tmp = TREE_CHAIN (tmp))
329 if (is_empty_class (TREE_TYPE (TREE_VALUE (tmp)))
330 && ! TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (tmp))))
331 {
332 tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (TREE_VALUE (tmp)));
333 TREE_VALUE (tmp) = build2 (COMPOUND_EXPR, TREE_TYPE (t),
334 TREE_VALUE (tmp), t);
335 }
336
337 function = build3 (CALL_EXPR, result_type, function, parms, NULL_TREE);
338 TREE_HAS_CONSTRUCTOR (function) = is_constructor;
339 TREE_NOTHROW (function) = nothrow;
340
341 return function;
342}
343
344/* Build something of the form ptr->method (args)
345 or object.method (args). This can also build
346 calls to constructors, and find friends.
347
348 Member functions always take their class variable
349 as a pointer.
350
351 INSTANCE is a class instance.
352
353 NAME is the name of the method desired, usually an IDENTIFIER_NODE.
354
355 PARMS help to figure out what that NAME really refers to.
356
357 BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE
358 down to the real instance type to use for access checking. We need this
359 information to get protected accesses correct.
360
361 FLAGS is the logical disjunction of zero or more LOOKUP_
362 flags. See cp-tree.h for more info.
363
364 If this is all OK, calls build_function_call with the resolved
365 member function.
366
367 This function must also handle being called to perform
368 initialization, promotion/coercion of arguments, and
369 instantiation of default parameters.
370
371 Note that NAME may refer to an instance variable name. If
372 `operator()()' is defined for the type of that field, then we return
373 that result. */
374
375/* New overloading code. */
376
377typedef struct z_candidate z_candidate;
378
379typedef struct candidate_warning candidate_warning;
380struct candidate_warning {
381 z_candidate *loser;
382 candidate_warning *next;
383};
384
385struct z_candidate {
386 /* The FUNCTION_DECL that will be called if this candidate is
387 selected by overload resolution. */
388 tree fn;
389 /* The arguments to use when calling this function. */
390 tree args;
391 /* The implicit conversion sequences for each of the arguments to
392 FN. */
393 conversion **convs;
394 /* The number of implicit conversion sequences. */
395 size_t num_convs;
396 /* If FN is a user-defined conversion, the standard conversion
397 sequence from the type returned by FN to the desired destination
398 type. */
399 conversion *second_conv;
400 int viable;
401 /* If FN is a member function, the binfo indicating the path used to
402 qualify the name of FN at the call site. This path is used to
403 determine whether or not FN is accessible if it is selected by
404 overload resolution. The DECL_CONTEXT of FN will always be a
405 (possibly improper) base of this binfo. */
406 tree access_path;
407 /* If FN is a non-static member function, the binfo indicating the
408 subobject to which the `this' pointer should be converted if FN
409 is selected by overload resolution. The type pointed to the by
410 the `this' pointer must correspond to the most derived class
411 indicated by the CONVERSION_PATH. */
412 tree conversion_path;
413 tree template_decl;
414 candidate_warning *warnings;
415 z_candidate *next;
416};
417
418/* Returns true iff T is a null pointer constant in the sense of
419 [conv.ptr]. */
420
421bool
422null_ptr_cst_p (tree t)
423{
424 /* [conv.ptr]
425
426 A null pointer constant is an integral constant expression
427 (_expr.const_) rvalue of integer type that evaluates to zero. */
428 t = integral_constant_value (t);
429 if (t == null_node)
430 return true;
431 if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))
432 {
433 STRIP_NOPS (t);
434 if (!TREE_CONSTANT_OVERFLOW (t))
435 return true;
436 }
437 return false;
438}
439
440/* Returns nonzero if PARMLIST consists of only default parms and/or
441 ellipsis. */
442
443bool
444sufficient_parms_p (tree parmlist)
445{
446 for (; parmlist && parmlist != void_list_node;
447 parmlist = TREE_CHAIN (parmlist))
448 if (!TREE_PURPOSE (parmlist))
449 return false;
450 return true;
451}
452
453/* Allocate N bytes of memory from the conversion obstack. The memory
454 is zeroed before being returned. */
455
456static void *
457conversion_obstack_alloc (size_t n)
458{
459 void *p;
460 if (!conversion_obstack_initialized)
461 {
462 gcc_obstack_init (&conversion_obstack);
463 conversion_obstack_initialized = true;
464 }
465 p = obstack_alloc (&conversion_obstack, n);
466 memset (p, 0, n);
467 return p;
468}
469
470/* Dynamically allocate a conversion. */
471
472static conversion *
473alloc_conversion (conversion_kind kind)
474{
475 conversion *c;
476 c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
477 c->kind = kind;
478 return c;
479}
480
481#ifdef ENABLE_CHECKING
482
483/* Make sure that all memory on the conversion obstack has been
484 freed. */
485
486void
487validate_conversion_obstack (void)
488{
489 if (conversion_obstack_initialized)
490 gcc_assert ((obstack_next_free (&conversion_obstack)
491 == obstack_base (&conversion_obstack)));
492}
493
494#endif /* ENABLE_CHECKING */
495
496/* Dynamically allocate an array of N conversions. */
497
498static conversion **
499alloc_conversions (size_t n)
500{
501 return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
502}
503
504static conversion *
505build_conv (conversion_kind code, tree type, conversion *from)
506{
507 conversion *t;
508 conversion_rank rank = CONVERSION_RANK (from);
509
510 /* We can't use buildl1 here because CODE could be USER_CONV, which
511 takes two arguments. In that case, the caller is responsible for
512 filling in the second argument. */
513 t = alloc_conversion (code);
514 t->type = type;
515 t->u.next = from;
516
517 switch (code)
518 {
519 case ck_ptr:
520 case ck_pmem:
521 case ck_base:
522 case ck_std:
523 if (rank < cr_std)
524 rank = cr_std;
525 break;
526
527 case ck_qual:
528 if (rank < cr_exact)
529 rank = cr_exact;
530 break;
531
532 default:
533 break;
534 }
535 t->rank = rank;
536 t->user_conv_p = (code == ck_user || from->user_conv_p);
537 t->bad_p = from->bad_p;
538 t->base_p = false;
539 return t;
540}
541
542/* Build a representation of the identity conversion from EXPR to
543 itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
544
545static conversion *
546build_identity_conv (tree type, tree expr)
547{
548 conversion *c;
549
550 c = alloc_conversion (ck_identity);
551 c->type = type;
552 c->u.expr = expr;
553
554 return c;
555}
556
557/* Converting from EXPR to TYPE was ambiguous in the sense that there
558 were multiple user-defined conversions to accomplish the job.
559 Build a conversion that indicates that ambiguity. */
560
561static conversion *
562build_ambiguous_conv (tree type, tree expr)
563{
564 conversion *c;
565
566 c = alloc_conversion (ck_ambig);
567 c->type = type;
568 c->u.expr = expr;
569
570 return c;
571}
572
573tree
574strip_top_quals (tree t)
575{
576 if (TREE_CODE (t) == ARRAY_TYPE)
577 return t;
578 return cp_build_qualified_type (t, 0);
579}
580
581/* Returns the standard conversion path (see [conv]) from type FROM to type
582 TO, if any. For proper handling of null pointer constants, you must
583 also pass the expression EXPR to convert from. If C_CAST_P is true,
584 this conversion is coming from a C-style cast. */
585
586static conversion *
587standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
588 int flags)
589{
590 enum tree_code fcode, tcode;
591 conversion *conv;
592 bool fromref = false;
593
594 to = non_reference (to);
595 if (TREE_CODE (from) == REFERENCE_TYPE)
596 {
597 fromref = true;
598 from = TREE_TYPE (from);
599 }
600 to = strip_top_quals (to);
601 from = strip_top_quals (from);
602
603 if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
604 && expr && type_unknown_p (expr))
605 {
606 expr = instantiate_type (to, expr, tf_conv);
607 if (expr == error_mark_node)
608 return NULL;
609 from = TREE_TYPE (expr);
610 }
611
612 fcode = TREE_CODE (from);
613 tcode = TREE_CODE (to);
614
615 conv = build_identity_conv (from, expr);
616 if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
617 {
618 from = type_decays_to (from);
619 fcode = TREE_CODE (from);
620 conv = build_conv (ck_lvalue, from, conv);
621 }
622 else if (fromref || (expr && lvalue_p (expr)))
623 {
624 if (expr)
625 {
626 tree bitfield_type;
627 bitfield_type = is_bitfield_expr_with_lowered_type (expr);
628 if (bitfield_type)
629 {
630 from = strip_top_quals (bitfield_type);
631 fcode = TREE_CODE (from);
632 }
633 }
634 conv = build_conv (ck_rvalue, from, conv);
635 }
636
637 /* Allow conversion between `__complex__' data types. */
638 if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
639 {
640 /* The standard conversion sequence to convert FROM to TO is
641 the standard conversion sequence to perform componentwise
642 conversion. */
643 conversion *part_conv = standard_conversion
644 (TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags);
645
646 if (part_conv)
647 {
648 conv = build_conv (part_conv->kind, to, conv);
649 conv->rank = part_conv->rank;
650 }
651 else
652 conv = NULL;
653
654 return conv;
655 }
656
657 if (same_type_p (from, to))
658 return conv;
659
660 if ((tcode == POINTER_TYPE || TYPE_PTR_TO_MEMBER_P (to))
661 && expr && null_ptr_cst_p (expr))
662 conv = build_conv (ck_std, to, conv);
663 else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
664 || (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
665 {
666 /* For backwards brain damage compatibility, allow interconversion of
667 pointers and integers with a pedwarn. */
668 conv = build_conv (ck_std, to, conv);
669 conv->bad_p = true;
670 }
671 else if (tcode == ENUMERAL_TYPE && fcode == INTEGER_TYPE)
672 {
673 /* For backwards brain damage compatibility, allow interconversion of
674 enums and integers with a pedwarn. */
675 conv = build_conv (ck_std, to, conv);
676 conv->bad_p = true;
677 }
678 else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
679 || (TYPE_PTRMEM_P (to) && TYPE_PTRMEM_P (from)))
680 {
681 tree to_pointee;
682 tree from_pointee;
683
684 if (tcode == POINTER_TYPE
685 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from),
686 TREE_TYPE (to)))
687 ;
688 else if (VOID_TYPE_P (TREE_TYPE (to))
689 && !TYPE_PTRMEM_P (from)
690 && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE)
691 {
692 from = build_pointer_type
693 (cp_build_qualified_type (void_type_node,
694 cp_type_quals (TREE_TYPE (from))));
695 conv = build_conv (ck_ptr, from, conv);
696 }
697 else if (TYPE_PTRMEM_P (from))
698 {
699 tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
700 tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
701
702 if (DERIVED_FROM_P (fbase, tbase)
703 && (same_type_ignoring_top_level_qualifiers_p
704 (TYPE_PTRMEM_POINTED_TO_TYPE (from),
705 TYPE_PTRMEM_POINTED_TO_TYPE (to))))
706 {
707 from = build_ptrmem_type (tbase,
708 TYPE_PTRMEM_POINTED_TO_TYPE (from));
709 conv = build_conv (ck_pmem, from, conv);
710 }
711 else if (!same_type_p (fbase, tbase))
712 return NULL;
713 }
714 else if (IS_AGGR_TYPE (TREE_TYPE (from))
715 && IS_AGGR_TYPE (TREE_TYPE (to))
716 /* [conv.ptr]
717
718 An rvalue of type "pointer to cv D," where D is a
719 class type, can be converted to an rvalue of type
720 "pointer to cv B," where B is a base class (clause
721 _class.derived_) of D. If B is an inaccessible
722 (clause _class.access_) or ambiguous
723 (_class.member.lookup_) base class of D, a program
724 that necessitates this conversion is ill-formed.
725 Therefore, we use DERIVED_FROM_P, and do not check
726 access or uniqueness. */
727 && DERIVED_FROM_P (TREE_TYPE (to), TREE_TYPE (from))
728 /* If FROM is not yet complete, then we must be parsing
729 the body of a class. We know what's derived from
730 what, but we can't actually perform a
731 derived-to-base conversion. For example, in:
732
733 struct D : public B {
734 static const int i = sizeof((B*)(D*)0);
735 };
736
737 the D*-to-B* conversion is a reinterpret_cast, not a
738 static_cast. */
739 && COMPLETE_TYPE_P (TREE_TYPE (from)))
740 {
741 from =
742 cp_build_qualified_type (TREE_TYPE (to),
743 cp_type_quals (TREE_TYPE (from)));
744 from = build_pointer_type (from);
745 conv = build_conv (ck_ptr, from, conv);
746 conv->base_p = true;
747 }
748
749 if (tcode == POINTER_TYPE)
750 {
751 to_pointee = TREE_TYPE (to);
752 from_pointee = TREE_TYPE (from);
753 }
754 else
755 {
756 to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
757 from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
758 }
759
760 if (same_type_p (from, to))
761 /* OK */;
762 else if (c_cast_p && comp_ptr_ttypes_const (to, from))
763 /* In a C-style cast, we ignore CV-qualification because we
764 are allowed to perform a static_cast followed by a
765 const_cast. */
766 conv = build_conv (ck_qual, to, conv);
767 else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
768 conv = build_conv (ck_qual, to, conv);
769 else if (expr && string_conv_p (to, expr, 0))
770 /* converting from string constant to char *. */
771 conv = build_conv (ck_qual, to, conv);
772 else if (ptr_reasonably_similar (to_pointee, from_pointee))
773 {
774 conv = build_conv (ck_ptr, to, conv);
775 conv->bad_p = true;
776 }
777 else
778 return NULL;
779
780 from = to;
781 }
782 else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
783 {
784 tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
785 tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
786 tree fbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fromfn)));
787 tree tbase = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (tofn)));
788
789 if (!DERIVED_FROM_P (fbase, tbase)
790 || !same_type_p (TREE_TYPE (fromfn), TREE_TYPE (tofn))
791 || !compparms (TREE_CHAIN (TYPE_ARG_TYPES (fromfn)),
792 TREE_CHAIN (TYPE_ARG_TYPES (tofn)))
793 || cp_type_quals (fbase) != cp_type_quals (tbase))
794 return NULL;
795
796 from = cp_build_qualified_type (tbase, cp_type_quals (fbase));
797 from = build_method_type_directly (from,
798 TREE_TYPE (fromfn),
799 TREE_CHAIN (TYPE_ARG_TYPES (fromfn)));
800 from = build_ptrmemfunc_type (build_pointer_type (from));
801 conv = build_conv (ck_pmem, from, conv);
802 conv->base_p = true;
803 }
804 else if (tcode == BOOLEAN_TYPE)
805 {
806 /* [conv.bool]
807
808 An rvalue of arithmetic, enumeration, pointer, or pointer to
809 member type can be converted to an rvalue of type bool. */
810 if (ARITHMETIC_TYPE_P (from)
811 || fcode == ENUMERAL_TYPE
812 || fcode == POINTER_TYPE
813 || TYPE_PTR_TO_MEMBER_P (from))
814 {
815 conv = build_conv (ck_std, to, conv);
816 if (fcode == POINTER_TYPE
817 || TYPE_PTRMEM_P (from)
818 || (TYPE_PTRMEMFUNC_P (from)
819 && conv->rank < cr_pbool))
820 conv->rank = cr_pbool;
821 return conv;
822 }
823
824 return NULL;
825 }
826 /* We don't check for ENUMERAL_TYPE here because there are no standard
827 conversions to enum type. */
828 else if (tcode == INTEGER_TYPE || tcode == BOOLEAN_TYPE
829 || tcode == REAL_TYPE)
830 {
831 if (! (INTEGRAL_CODE_P (fcode) || fcode == REAL_TYPE))
832 return NULL;
833 conv = build_conv (ck_std, to, conv);
834
835 /* Give this a better rank if it's a promotion. */
836 if (same_type_p (to, type_promotes_to (from))
837 && conv->u.next->rank <= cr_promotion)
838 conv->rank = cr_promotion;
839 }
840 else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
841 && vector_types_convertible_p (from, to))
842 return build_conv (ck_std, to, conv);
843 else if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE)
844 && IS_AGGR_TYPE (to) && IS_AGGR_TYPE (from)
845 && is_properly_derived_from (from, to))
846 {
847 if (conv->kind == ck_rvalue)
848 conv = conv->u.next;
849 conv = build_conv (ck_base, to, conv);
850 /* The derived-to-base conversion indicates the initialization
851 of a parameter with base type from an object of a derived
852 type. A temporary object is created to hold the result of
853 the conversion. */
854 conv->need_temporary_p = true;
855 }
856 else
857 return NULL;
858
859 return conv;
860}
861
862/* Returns nonzero if T1 is reference-related to T2. */
863
864static bool
865reference_related_p (tree t1, tree t2)
866{
867 t1 = TYPE_MAIN_VARIANT (t1);
868 t2 = TYPE_MAIN_VARIANT (t2);
869
870 /* [dcl.init.ref]
871
872 Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
873 to "cv2 T2" if T1 is the same type as T2, or T1 is a base class
874 of T2. */
875 return (same_type_p (t1, t2)
876 || (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
877 && DERIVED_FROM_P (t1, t2)));
878}
879
880/* Returns nonzero if T1 is reference-compatible with T2. */
881
882static bool
883reference_compatible_p (tree t1, tree t2)
884{
885 /* [dcl.init.ref]
886
887 "cv1 T1" is reference compatible with "cv2 T2" if T1 is
888 reference-related to T2 and cv1 is the same cv-qualification as,
889 or greater cv-qualification than, cv2. */
890 return (reference_related_p (t1, t2)
891 && at_least_as_qualified_p (t1, t2));
892}
893
894/* Determine whether or not the EXPR (of class type S) can be
895 converted to T as in [over.match.ref]. */
896
897static conversion *
898convert_class_to_reference (tree t, tree s, tree expr)
899{
900 tree conversions;
901 tree arglist;
902 conversion *conv;
903 tree reference_type;
904 struct z_candidate *candidates;
905 struct z_candidate *cand;
906 bool any_viable_p;
907
908 conversions = lookup_conversions (s);
909 if (!conversions)
910 return NULL;
911
912 /* [over.match.ref]
913
914 Assuming that "cv1 T" is the underlying type of the reference
915 being initialized, and "cv S" is the type of the initializer
916 expression, with S a class type, the candidate functions are
917 selected as follows:
918
919 --The conversion functions of S and its base classes are
920 considered. Those that are not hidden within S and yield type
921 "reference to cv2 T2", where "cv1 T" is reference-compatible
922 (_dcl.init.ref_) with "cv2 T2", are candidate functions.
923
924 The argument list has one argument, which is the initializer
925 expression. */
926
927 candidates = 0;
928
929 /* Conceptually, we should take the address of EXPR and put it in
930 the argument list. Unfortunately, however, that can result in
931 error messages, which we should not issue now because we are just
932 trying to find a conversion operator. Therefore, we use NULL,
933 cast to the appropriate type. */
934 arglist = build_int_cst (build_pointer_type (s), 0);
935 arglist = build_tree_list (NULL_TREE, arglist);
936
937 reference_type = build_reference_type (t);
938
939 while (conversions)
940 {
941 tree fns = TREE_VALUE (conversions);
942
943 for (; fns; fns = OVL_NEXT (fns))
944 {
945 tree f = OVL_CURRENT (fns);
946 tree t2 = TREE_TYPE (TREE_TYPE (f));
947
948 cand = NULL;
949
950 /* If this is a template function, try to get an exact
951 match. */
952 if (TREE_CODE (f) == TEMPLATE_DECL)
953 {
954 cand = add_template_candidate (&candidates,
955 f, s,
956 NULL_TREE,
957 arglist,
958 reference_type,
959 TYPE_BINFO (s),
960 TREE_PURPOSE (conversions),
961 LOOKUP_NORMAL,
962 DEDUCE_CONV);
963
964 if (cand)
965 {
966 /* Now, see if the conversion function really returns
967 an lvalue of the appropriate type. From the
968 point of view of unification, simply returning an
969 rvalue of the right type is good enough. */
970 f = cand->fn;
971 t2 = TREE_TYPE (TREE_TYPE (f));
972 if (TREE_CODE (t2) != REFERENCE_TYPE
973 || !reference_compatible_p (t, TREE_TYPE (t2)))
974 {
975 candidates = candidates->next;
976 cand = NULL;
977 }
978 }
979 }
980 else if (TREE_CODE (t2) == REFERENCE_TYPE
981 && reference_compatible_p (t, TREE_TYPE (t2)))
982 cand = add_function_candidate (&candidates, f, s, arglist,
983 TYPE_BINFO (s),
984 TREE_PURPOSE (conversions),
985 LOOKUP_NORMAL);
986
987 if (cand)
988 {
989 conversion *identity_conv;
990 /* Build a standard conversion sequence indicating the
991 binding from the reference type returned by the
992 function to the desired REFERENCE_TYPE. */
993 identity_conv
994 = build_identity_conv (TREE_TYPE (TREE_TYPE
995 (TREE_TYPE (cand->fn))),
996 NULL_TREE);
997 cand->second_conv
998 = (direct_reference_binding
999 (reference_type, identity_conv));
1000 cand->second_conv->bad_p |= cand->convs[0]->bad_p;
1001 }
1002 }
1003 conversions = TREE_CHAIN (conversions);
1004 }
1005
1006 candidates = splice_viable (candidates, pedantic, &any_viable_p);
1007 /* If none of the conversion functions worked out, let our caller
1008 know. */
1009 if (!any_viable_p)
1010 return NULL;
1011
1012 cand = tourney (candidates);
1013 if (!cand)
1014 return NULL;
1015
1016 /* Now that we know that this is the function we're going to use fix
1017 the dummy first argument. */
1018 cand->args = tree_cons (NULL_TREE,
1019 build_this (expr),
1020 TREE_CHAIN (cand->args));
1021
1022 /* Build a user-defined conversion sequence representing the
1023 conversion. */
1024 conv = build_conv (ck_user,
1025 TREE_TYPE (TREE_TYPE (cand->fn)),
1026 build_identity_conv (TREE_TYPE (expr), expr));
1027 conv->cand = cand;
1028
1029 /* Merge it with the standard conversion sequence from the
1030 conversion function's return type to the desired type. */
1031 cand->second_conv = merge_conversion_sequences (conv, cand->second_conv);
1032
1033 if (cand->viable == -1)
1034 conv->bad_p = true;
1035
1036 return cand->second_conv;
1037}
1038
1039/* A reference of the indicated TYPE is being bound directly to the
1040 expression represented by the implicit conversion sequence CONV.
1041 Return a conversion sequence for this binding. */
1042
1043static conversion *
1044direct_reference_binding (tree type, conversion *conv)
1045{
1046 tree t;
1047
1048 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
1049 gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE);
1050
1051 t = TREE_TYPE (type);
1052
1053 /* [over.ics.rank]
1054
1055 When a parameter of reference type binds directly
1056 (_dcl.init.ref_) to an argument expression, the implicit
1057 conversion sequence is the identity conversion, unless the
1058 argument expression has a type that is a derived class of the
1059 parameter type, in which case the implicit conversion sequence is
1060 a derived-to-base Conversion.
1061
1062 If the parameter binds directly to the result of applying a
1063 conversion function to the argument expression, the implicit
1064 conversion sequence is a user-defined conversion sequence
1065 (_over.ics.user_), with the second standard conversion sequence
1066 either an identity conversion or, if the conversion function
1067 returns an entity of a type that is a derived class of the
1068 parameter type, a derived-to-base conversion. */
1069 if (!same_type_ignoring_top_level_qualifiers_p (t, conv->type))
1070 {
1071 /* Represent the derived-to-base conversion. */
1072 conv = build_conv (ck_base, t, conv);
1073 /* We will actually be binding to the base-class subobject in
1074 the derived class, so we mark this conversion appropriately.
1075 That way, convert_like knows not to generate a temporary. */
1076 conv->need_temporary_p = false;
1077 }
1078 return build_conv (ck_ref_bind, type, conv);
1079}
1080
1081/* Returns the conversion path from type FROM to reference type TO for
1082 purposes of reference binding. For lvalue binding, either pass a
1083 reference type to FROM or an lvalue expression to EXPR. If the
1084 reference will be bound to a temporary, NEED_TEMPORARY_P is set for
1085 the conversion returned. If C_CAST_P is true, this
1086 conversion is coming from a C-style cast. */
1087
1088static conversion *
1089reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
1090{
1091 conversion *conv = NULL;
1092 tree to = TREE_TYPE (rto);
1093 tree from = rfrom;
1094 bool related_p;
1095 bool compatible_p;
1096 cp_lvalue_kind lvalue_p = clk_none;
1097
1098 if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
1099 {
1100 expr = instantiate_type (to, expr, tf_none);
1101 if (expr == error_mark_node)
1102 return NULL;
1103 from = TREE_TYPE (expr);
1104 }
1105
1106 if (TREE_CODE (from) == REFERENCE_TYPE)
1107 {
1108 /* Anything with reference type is an lvalue. */
1109 lvalue_p = clk_ordinary;
1110 from = TREE_TYPE (from);
1111 }
1112 else if (expr)
1113 lvalue_p = real_lvalue_p (expr);
1114
1115 /* Figure out whether or not the types are reference-related and
1116 reference compatible. We have do do this after stripping
1117 references from FROM. */
1118 related_p = reference_related_p (to, from);
1119 /* If this is a C cast, first convert to an appropriately qualified
1120 type, so that we can later do a const_cast to the desired type. */
1121 if (related_p && c_cast_p
1122 && !at_least_as_qualified_p (to, from))
1123 to = build_qualified_type (to, cp_type_quals (from));
1124 compatible_p = reference_compatible_p (to, from);
1125
1126 if (lvalue_p && compatible_p)
1127 {
1128 /* [dcl.init.ref]
1129
1130 If the initializer expression
1131
1132 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
1133 is reference-compatible with "cv2 T2,"
1134
1135 the reference is bound directly to the initializer expression
1136 lvalue. */
1137 conv = build_identity_conv (from, expr);
1138 conv = direct_reference_binding (rto, conv);
1139 if ((lvalue_p & clk_bitfield) != 0
1140 || ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
1141 /* For the purposes of overload resolution, we ignore the fact
1142 this expression is a bitfield or packed field. (In particular,
1143 [over.ics.ref] says specifically that a function with a
1144 non-const reference parameter is viable even if the
1145 argument is a bitfield.)
1146
1147 However, when we actually call the function we must create
1148 a temporary to which to bind the reference. If the
1149 reference is volatile, or isn't const, then we cannot make
1150 a temporary, so we just issue an error when the conversion
1151 actually occurs. */
1152 conv->need_temporary_p = true;
1153
1154 return conv;
1155 }
1156 else if (CLASS_TYPE_P (from) && !(flags & LOOKUP_NO_CONVERSION))
1157 {
1158 /* [dcl.init.ref]
1159
1160 If the initializer expression
1161
1162 -- has a class type (i.e., T2 is a class type) can be
1163 implicitly converted to an lvalue of type "cv3 T3," where
1164 "cv1 T1" is reference-compatible with "cv3 T3". (this
1165 conversion is selected by enumerating the applicable
1166 conversion functions (_over.match.ref_) and choosing the
1167 best one through overload resolution. (_over.match_).
1168
1169 the reference is bound to the lvalue result of the conversion
1170 in the second case. */
1171 conv = convert_class_to_reference (to, from, expr);
1172 if (conv)
1173 return conv;
1174 }
1175
1176 /* From this point on, we conceptually need temporaries, even if we
1177 elide them. Only the cases above are "direct bindings". */
1178 if (flags & LOOKUP_NO_TEMP_BIND)
1179 return NULL;
1180
1181 /* [over.ics.rank]
1182
1183 When a parameter of reference type is not bound directly to an
1184 argument expression, the conversion sequence is the one required
1185 to convert the argument expression to the underlying type of the
1186 reference according to _over.best.ics_. Conceptually, this
1187 conversion sequence corresponds to copy-initializing a temporary
1188 of the underlying type with the argument expression. Any
1189 difference in top-level cv-qualification is subsumed by the
1190 initialization itself and does not constitute a conversion. */
1191
1192 /* [dcl.init.ref]
1193
1194 Otherwise, the reference shall be to a non-volatile const type. */
1195 if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
1196 return NULL;
1197
1198 /* [dcl.init.ref]
1199
1200 If the initializer expression is an rvalue, with T2 a class type,
1201 and "cv1 T1" is reference-compatible with "cv2 T2", the reference
1202 is bound in one of the following ways:
1203
1204 -- The reference is bound to the object represented by the rvalue
1205 or to a sub-object within that object.
1206
1207 -- ...
1208
1209 We use the first alternative. The implicit conversion sequence
1210 is supposed to be same as we would obtain by generating a
1211 temporary. Fortunately, if the types are reference compatible,
1212 then this is either an identity conversion or the derived-to-base
1213 conversion, just as for direct binding. */
1214 if (CLASS_TYPE_P (from) && compatible_p)
1215 {
1216 conv = build_identity_conv (from, expr);
1217 conv = direct_reference_binding (rto, conv);
1218 if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
1219 conv->u.next->check_copy_constructor_p = true;
1220 return conv;
1221 }
1222
1223 /* [dcl.init.ref]
1224
1225 Otherwise, a temporary of type "cv1 T1" is created and
1226 initialized from the initializer expression using the rules for a
1227 non-reference copy initialization. If T1 is reference-related to
1228 T2, cv1 must be the same cv-qualification as, or greater
1229 cv-qualification than, cv2; otherwise, the program is ill-formed. */
1230 if (related_p && !at_least_as_qualified_p (to, from))
1231 return NULL;
1232
1233 conv = implicit_conversion (to, from, expr, c_cast_p,
1234 flags);
1235 if (!conv)
1236 return NULL;
1237
1238 conv = build_conv (ck_ref_bind, rto, conv);
1239 /* This reference binding, unlike those above, requires the
1240 creation of a temporary. */
1241 conv->need_temporary_p = true;
1242
1243 return conv;
1244}
1245
1246/* Returns the implicit conversion sequence (see [over.ics]) from type
1247 FROM to type TO. The optional expression EXPR may affect the
1248 conversion. FLAGS are the usual overloading flags. Only
1249 LOOKUP_NO_CONVERSION is significant. If C_CAST_P is true, this
1250 conversion is coming from a C-style cast. */
1251
1252static conversion *
1253implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
1254 int flags)
1255{
1256 conversion *conv;
1257
1258 if (from == error_mark_node || to == error_mark_node
1259 || expr == error_mark_node)
1260 return NULL;
1261
1262 if (TREE_CODE (to) == REFERENCE_TYPE)
1263 conv = reference_binding (to, from, expr, c_cast_p, flags);
1264 else
1265 conv = standard_conversion (to, from, expr, c_cast_p, flags);
1266
1267 if (conv)
1268 return conv;
1269
1270 if (expr != NULL_TREE
1271 && (IS_AGGR_TYPE (from)
1272 || IS_AGGR_TYPE (to))
1273 && (flags & LOOKUP_NO_CONVERSION) == 0)
1274 {
1275 struct z_candidate *cand;
1276
1277 cand = build_user_type_conversion_1
1278 (to, expr, LOOKUP_ONLYCONVERTING);
1279 if (cand)
1280 conv = cand->second_conv;
1281
1282 /* We used to try to bind a reference to a temporary here, but that
1283 is now handled by the recursive call to this function at the end
1284 of reference_binding. */
1285 return conv;
1286 }
1287
1288 return NULL;
1289}
1290
1291/* Add a new entry to the list of candidates. Used by the add_*_candidate
1292 functions. */
1293
1294static struct z_candidate *
1295add_candidate (struct z_candidate **candidates,
1296 tree fn, tree args,
1297 size_t num_convs, conversion **convs,
1298 tree access_path, tree conversion_path,
1299 int viable)
1300{
1301 struct z_candidate *cand = (struct z_candidate *)
1302 conversion_obstack_alloc (sizeof (struct z_candidate));
1303
1304 cand->fn = fn;
1305 cand->args = args;
1306 cand->convs = convs;
1307 cand->num_convs = num_convs;
1308 cand->access_path = access_path;
1309 cand->conversion_path = conversion_path;
1310 cand->viable = viable;
1311 cand->next = *candidates;
1312 *candidates = cand;
1313
1314 return cand;
1315}
1316
1317/* Create an overload candidate for the function or method FN called with
1318 the argument list ARGLIST and add it to CANDIDATES. FLAGS is passed on
1319 to implicit_conversion.
1320
1321 CTYPE, if non-NULL, is the type we want to pretend this function
1322 comes from for purposes of overload resolution. */
1323
1324static struct z_candidate *
1325add_function_candidate (struct z_candidate **candidates,
1326 tree fn, tree ctype, tree arglist,
1327 tree access_path, tree conversion_path,
1328 int flags)
1329{
1330 tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
1331 int i, len;
1332 conversion **convs;
1333 tree parmnode, argnode;
1334 tree orig_arglist;
1335 int viable = 1;
1336
1337 /* At this point we should not see any functions which haven't been
1338 explicitly declared, except for friend functions which will have
1339 been found using argument dependent lookup. */
1340 gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn));
1341
1342 /* The `this', `in_chrg' and VTT arguments to constructors are not
1343 considered in overload resolution. */
1344 if (DECL_CONSTRUCTOR_P (fn))
1345 {
1346 parmlist = skip_artificial_parms_for (fn, parmlist);
1347 orig_arglist = arglist;
1348 arglist = skip_artificial_parms_for (fn, arglist);
1349 }
1350 else
1351 orig_arglist = arglist;
1352
1353 len = list_length (arglist);
1354 convs = alloc_conversions (len);
1355
1356 /* 13.3.2 - Viable functions [over.match.viable]
1357 First, to be a viable function, a candidate function shall have enough
1358 parameters to agree in number with the arguments in the list.
1359
1360 We need to check this first; otherwise, checking the ICSes might cause
1361 us to produce an ill-formed template instantiation. */
1362
1363 parmnode = parmlist;
1364 for (i = 0; i < len; ++i)
1365 {
1366 if (parmnode == NULL_TREE || parmnode == void_list_node)
1367 break;
1368 parmnode = TREE_CHAIN (parmnode);
1369 }
1370
1371 if (i < len && parmnode)
1372 viable = 0;
1373
1374 /* Make sure there are default args for the rest of the parms. */
1375 else if (!sufficient_parms_p (parmnode))
1376 viable = 0;
1377
1378 if (! viable)
1379 goto out;
1380
1381 /* Second, for F to be a viable function, there shall exist for each
1382 argument an implicit conversion sequence that converts that argument
1383 to the corresponding parameter of F. */
1384
1385 parmnode = parmlist;
1386 argnode = arglist;
1387
1388 for (i = 0; i < len; ++i)
1389 {
1390 tree arg = TREE_VALUE (argnode);
1391 tree argtype = lvalue_type (arg);
1392 conversion *t;
1393 int is_this;
1394
1395 if (parmnode == void_list_node)
1396 break;
1397
1398 is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
1399 && ! DECL_CONSTRUCTOR_P (fn));
1400
1401 if (parmnode)
1402 {
1403 tree parmtype = TREE_VALUE (parmnode);
1404
1405 /* The type of the implicit object parameter ('this') for
1406 overload resolution is not always the same as for the
1407 function itself; conversion functions are considered to
1408 be members of the class being converted, and functions
1409 introduced by a using-declaration are considered to be
1410 members of the class that uses them.
1411
1412 Since build_over_call ignores the ICS for the `this'
1413 parameter, we can just change the parm type. */
1414 if (ctype && is_this)
1415 {
1416 parmtype
1417 = build_qualified_type (ctype,
1418 TYPE_QUALS (TREE_TYPE (parmtype)));
1419 parmtype = build_pointer_type (parmtype);
1420 }
1421
1422 t = implicit_conversion (parmtype, argtype, arg,
1423 /*c_cast_p=*/false, flags);
1424 }
1425 else
1426 {
1427 t = build_identity_conv (argtype, arg);
1428 t->ellipsis_p = true;
1429 }
1430
1431 if (t && is_this)
1432 t->this_p = true;
1433
1434 convs[i] = t;
1435 if (! t)
1436 {
1437 viable = 0;
1438 break;
1439 }
1440
1441 if (t->bad_p)
1442 viable = -1;
1443
1444 if (parmnode)
1445 parmnode = TREE_CHAIN (parmnode);
1446 argnode = TREE_CHAIN (argnode);
1447 }
1448
1449 out:
1450 return add_candidate (candidates, fn, orig_arglist, len, convs,
1451 access_path, conversion_path, viable);
1452}
1453
1454/* Create an overload candidate for the conversion function FN which will
1455 be invoked for expression OBJ, producing a pointer-to-function which
1456 will in turn be called with the argument list ARGLIST, and add it to
1457 CANDIDATES. FLAGS is passed on to implicit_conversion.
1458
1459 Actually, we don't really care about FN; we care about the type it
1460 converts to. There may be multiple conversion functions that will
1461 convert to that type, and we rely on build_user_type_conversion_1 to
1462 choose the best one; so when we create our candidate, we record the type
1463 instead of the function. */
1464
1465static struct z_candidate *
1466add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
1467 tree arglist, tree access_path, tree conversion_path)
1468{
1469 tree totype = TREE_TYPE (TREE_TYPE (fn));
1470 int i, len, viable, flags;
1471 tree parmlist, parmnode, argnode;
1472 conversion **convs;
1473
1474 for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
1475 parmlist = TREE_TYPE (parmlist);
1476 parmlist = TYPE_ARG_TYPES (parmlist);
1477
1478 len = list_length (arglist) + 1;
1479 convs = alloc_conversions (len);
1480 parmnode = parmlist;
1481 argnode = arglist;
1482 viable = 1;
1483 flags = LOOKUP_NORMAL;
1484
1485 /* Don't bother looking up the same type twice. */
1486 if (*candidates && (*candidates)->fn == totype)
1487 return NULL;
1488
1489 for (i = 0; i < len; ++i)
1490 {
1491 tree arg = i == 0 ? obj : TREE_VALUE (argnode);
1492 tree argtype = lvalue_type (arg);
1493 conversion *t;
1494
1495 if (i == 0)
1496 t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false,
1497 flags);
1498 else if (parmnode == void_list_node)
1499 break;
1500 else if (parmnode)
1501 t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
1502 /*c_cast_p=*/false, flags);
1503 else
1504 {
1505 t = build_identity_conv (argtype, arg);
1506 t->ellipsis_p = true;
1507 }
1508
1509 convs[i] = t;
1510 if (! t)
1511 break;
1512
1513 if (t->bad_p)
1514 viable = -1;
1515
1516 if (i == 0)
1517 continue;
1518
1519 if (parmnode)
1520 parmnode = TREE_CHAIN (parmnode);
1521 argnode = TREE_CHAIN (argnode);
1522 }
1523
1524 if (i < len)
1525 viable = 0;
1526
1527 if (!sufficient_parms_p (parmnode))
1528 viable = 0;
1529
1530 return add_candidate (candidates, totype, arglist, len, convs,
1531 access_path, conversion_path, viable);
1532}
1533
1534static void
1535build_builtin_candidate (struct z_candidate **candidates, tree fnname,
1536 tree type1, tree type2, tree *args, tree *argtypes,
1537 int flags)
1538{
1539 conversion *t;
1540 conversion **convs;
1541 size_t num_convs;
1542 int viable = 1, i;
1543 tree types[2];
1544
1545 types[0] = type1;
1546 types[1] = type2;
1547
1548 num_convs = args[2] ? 3 : (args[1] ? 2 : 1);
1549 convs = alloc_conversions (num_convs);
1550
1551 for (i = 0; i < 2; ++i)
1552 {
1553 if (! args[i])
1554 break;
1555
1556 t = implicit_conversion (types[i], argtypes[i], args[i],
1557 /*c_cast_p=*/false, flags);
1558 if (! t)
1559 {
1560 viable = 0;
1561 /* We need something for printing the candidate. */
1562 t = build_identity_conv (types[i], NULL_TREE);
1563 }
1564 else if (t->bad_p)
1565 viable = 0;
1566 convs[i] = t;
1567 }
1568
1569 /* For COND_EXPR we rearranged the arguments; undo that now. */
1570 if (args[2])
1571 {
1572 convs[2] = convs[1];
1573 convs[1] = convs[0];
1574 t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
1575 /*c_cast_p=*/false, flags);
1576 if (t)
1577 convs[0] = t;
1578 else
1579 viable = 0;
1580 }
1581
1582 add_candidate (candidates, fnname, /*args=*/NULL_TREE,
1583 num_convs, convs,
1584 /*access_path=*/NULL_TREE,
1585 /*conversion_path=*/NULL_TREE,
1586 viable);
1587}
1588
1589static bool
1590is_complete (tree t)
1591{
1592 return COMPLETE_TYPE_P (complete_type (t));
1593}
1594
1595/* Returns nonzero if TYPE is a promoted arithmetic type. */
1596
1597static bool
1598promoted_arithmetic_type_p (tree type)
1599{
1600 /* [over.built]
1601
1602 In this section, the term promoted integral type is used to refer
1603 to those integral types which are preserved by integral promotion
1604 (including e.g. int and long but excluding e.g. char).
1605 Similarly, the term promoted arithmetic type refers to promoted
1606 integral types plus floating types. */
1607 return ((INTEGRAL_TYPE_P (type)
1608 && same_type_p (type_promotes_to (type), type))
1609 || TREE_CODE (type) == REAL_TYPE);
1610}
1611
1612/* Create any builtin operator overload candidates for the operator in
1613 question given the converted operand types TYPE1 and TYPE2. The other
1614 args are passed through from add_builtin_candidates to
1615 build_builtin_candidate.
1616
1617 TYPE1 and TYPE2 may not be permissible, and we must filter them.
1618 If CODE is requires candidates operands of the same type of the kind
1619 of which TYPE1 and TYPE2 are, we add both candidates
1620 CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
1621
1622static void
1623add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
1624 enum tree_code code2, tree fnname, tree type1,
1625 tree type2, tree *args, tree *argtypes, int flags)
1626{
1627 switch (code)
1628 {
1629 case POSTINCREMENT_EXPR:
1630 case POSTDECREMENT_EXPR:
1631 args[1] = integer_zero_node;
1632 type2 = integer_type_node;
1633 break;
1634 default:
1635 break;
1636 }
1637
1638 switch (code)
1639 {
1640
1641/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
1642 and VQ is either volatile or empty, there exist candidate operator
1643 functions of the form
1644 VQ T& operator++(VQ T&);
1645 T operator++(VQ T&, int);
1646 5 For every pair T, VQ), where T is an enumeration type or an arithmetic
1647 type other than bool, and VQ is either volatile or empty, there exist
1648 candidate operator functions of the form
1649 VQ T& operator--(VQ T&);
1650 T operator--(VQ T&, int);
1651 6 For every pair T, VQ), where T is a cv-qualified or cv-unqualified
1652 complete object type, and VQ is either volatile or empty, there exist
1653 candidate operator functions of the form
1654 T*VQ& operator++(T*VQ&);
1655 T*VQ& operator--(T*VQ&);
1656 T* operator++(T*VQ&, int);
1657 T* operator--(T*VQ&, int); */
1658
1659 case POSTDECREMENT_EXPR:
1660 case PREDECREMENT_EXPR:
1661 if (TREE_CODE (type1) == BOOLEAN_TYPE)
1662 return;
1663 case POSTINCREMENT_EXPR:
1664 case PREINCREMENT_EXPR:
1665 if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
1666 {
1667 type1 = build_reference_type (type1);
1668 break;
1669 }
1670 return;
1671
1672/* 7 For every cv-qualified or cv-unqualified complete object type T, there
1673 exist candidate operator functions of the form
1674
1675 T& operator*(T*);
1676
1677 8 For every function type T, there exist candidate operator functions of
1678 the form
1679 T& operator*(T*); */
1680
1681 case INDIRECT_REF:
1682 if (TREE_CODE (type1) == POINTER_TYPE
1683 && (TYPE_PTROB_P (type1)
1684 || TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
1685 break;
1686 return;
1687
1688/* 9 For every type T, there exist candidate operator functions of the form
1689 T* operator+(T*);
1690
1691 10For every promoted arithmetic type T, there exist candidate operator
1692 functions of the form
1693 T operator+(T);
1694 T operator-(T); */
1695
1696 case UNARY_PLUS_EXPR: /* unary + */
1697 if (TREE_CODE (type1) == POINTER_TYPE)
1698 break;
1699 case NEGATE_EXPR:
1700 if (ARITHMETIC_TYPE_P (type1))
1701 break;
1702 return;
1703
1704/* 11For every promoted integral type T, there exist candidate operator
1705 functions of the form
1706 T operator~(T); */
1707
1708 case BIT_NOT_EXPR:
1709 if (INTEGRAL_TYPE_P (type1))
1710 break;
1711 return;
1712
1713/* 12For every quintuple C1, C2, T, CV1, CV2), where C2 is a class type, C1
1714 is the same type as C2 or is a derived class of C2, T is a complete
1715 object type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
1716 there exist candidate operator functions of the form
1717 CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
1718 where CV12 is the union of CV1 and CV2. */
1719
1720 case MEMBER_REF:
1721 if (TREE_CODE (type1) == POINTER_TYPE
1722 && TYPE_PTR_TO_MEMBER_P (type2))
1723 {
1724 tree c1 = TREE_TYPE (type1);
1725 tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
1726
1727 if (IS_AGGR_TYPE (c1) && DERIVED_FROM_P (c2, c1)
1728 && (TYPE_PTRMEMFUNC_P (type2)
1729 || is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
1730 break;
1731 }
1732 return;
1733
1734/* 13For every pair of promoted arithmetic types L and R, there exist can-
1735 didate operator functions of the form
1736 LR operator*(L, R);
1737 LR operator/(L, R);
1738 LR operator+(L, R);
1739 LR operator-(L, R);
1740 bool operator<(L, R);
1741 bool operator>(L, R);
1742 bool operator<=(L, R);
1743 bool operator>=(L, R);
1744 bool operator==(L, R);
1745 bool operator!=(L, R);
1746 where LR is the result of the usual arithmetic conversions between
1747 types L and R.
1748
1749 14For every pair of types T and I, where T is a cv-qualified or cv-
1750 unqualified complete object type and I is a promoted integral type,
1751 there exist candidate operator functions of the form
1752 T* operator+(T*, I);
1753 T& operator[](T*, I);
1754 T* operator-(T*, I);
1755 T* operator+(I, T*);
1756 T& operator[](I, T*);
1757
1758 15For every T, where T is a pointer to complete object type, there exist
1759 candidate operator functions of the form112)
1760 ptrdiff_t operator-(T, T);
1761
1762 16For every pointer or enumeration type T, there exist candidate operator
1763 functions of the form
1764 bool operator<(T, T);
1765 bool operator>(T, T);
1766 bool operator<=(T, T);
1767 bool operator>=(T, T);
1768 bool operator==(T, T);
1769 bool operator!=(T, T);
1770
1771 17For every pointer to member type T, there exist candidate operator
1772 functions of the form
1773 bool operator==(T, T);
1774 bool operator!=(T, T); */
1775
1776 case MINUS_EXPR:
1777 if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
1778 break;
1779 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1780 {
1781 type2 = ptrdiff_type_node;
1782 break;
1783 }
1784 case MULT_EXPR:
1785 case TRUNC_DIV_EXPR:
1786 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1787 break;
1788 return;
1789
1790 case EQ_EXPR:
1791 case NE_EXPR:
1792 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1793 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2)))
1794 break;
1795 if (TYPE_PTR_TO_MEMBER_P (type1) && null_ptr_cst_p (args[1]))
1796 {
1797 type2 = type1;
1798 break;
1799 }
1800 if (TYPE_PTR_TO_MEMBER_P (type2) && null_ptr_cst_p (args[0]))
1801 {
1802 type1 = type2;
1803 break;
1804 }
1805 /* Fall through. */
1806 case LT_EXPR:
1807 case GT_EXPR:
1808 case LE_EXPR:
1809 case GE_EXPR:
1810 case MAX_EXPR:
1811 case MIN_EXPR:
1812 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1813 break;
1814 if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1815 break;
1816 if (TREE_CODE (type1) == ENUMERAL_TYPE
1817 && TREE_CODE (type2) == ENUMERAL_TYPE)
1818 break;
1819 if (TYPE_PTR_P (type1)
1820 && null_ptr_cst_p (args[1])
1821 && !uses_template_parms (type1))
1822 {
1823 type2 = type1;
1824 break;
1825 }
1826 if (null_ptr_cst_p (args[0])
1827 && TYPE_PTR_P (type2)
1828 && !uses_template_parms (type2))
1829 {
1830 type1 = type2;
1831 break;
1832 }
1833 return;
1834
1835 case PLUS_EXPR:
1836 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1837 break;
1838 case ARRAY_REF:
1839 if (INTEGRAL_TYPE_P (type1) && TYPE_PTROB_P (type2))
1840 {
1841 type1 = ptrdiff_type_node;
1842 break;
1843 }
1844 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1845 {
1846 type2 = ptrdiff_type_node;
1847 break;
1848 }
1849 return;
1850
1851/* 18For every pair of promoted integral types L and R, there exist candi-
1852 date operator functions of the form
1853 LR operator%(L, R);
1854 LR operator&(L, R);
1855 LR operator^(L, R);
1856 LR operator|(L, R);
1857 L operator<<(L, R);
1858 L operator>>(L, R);
1859 where LR is the result of the usual arithmetic conversions between
1860 types L and R. */
1861
1862 case TRUNC_MOD_EXPR:
1863 case BIT_AND_EXPR:
1864 case BIT_IOR_EXPR:
1865 case BIT_XOR_EXPR:
1866 case LSHIFT_EXPR:
1867 case RSHIFT_EXPR:
1868 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1869 break;
1870 return;
1871
1872/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
1873 type, VQ is either volatile or empty, and R is a promoted arithmetic
1874 type, there exist candidate operator functions of the form
1875 VQ L& operator=(VQ L&, R);
1876 VQ L& operator*=(VQ L&, R);
1877 VQ L& operator/=(VQ L&, R);
1878 VQ L& operator+=(VQ L&, R);
1879 VQ L& operator-=(VQ L&, R);
1880
1881 20For every pair T, VQ), where T is any type and VQ is either volatile
1882 or empty, there exist candidate operator functions of the form
1883 T*VQ& operator=(T*VQ&, T*);
1884
1885 21For every pair T, VQ), where T is a pointer to member type and VQ is
1886 either volatile or empty, there exist candidate operator functions of
1887 the form
1888 VQ T& operator=(VQ T&, T);
1889
1890 22For every triple T, VQ, I), where T is a cv-qualified or cv-
1891 unqualified complete object type, VQ is either volatile or empty, and
1892 I is a promoted integral type, there exist candidate operator func-
1893 tions of the form
1894 T*VQ& operator+=(T*VQ&, I);
1895 T*VQ& operator-=(T*VQ&, I);
1896
1897 23For every triple L, VQ, R), where L is an integral or enumeration
1898 type, VQ is either volatile or empty, and R is a promoted integral
1899 type, there exist candidate operator functions of the form
1900
1901 VQ L& operator%=(VQ L&, R);
1902 VQ L& operator<<=(VQ L&, R);
1903 VQ L& operator>>=(VQ L&, R);
1904 VQ L& operator&=(VQ L&, R);
1905 VQ L& operator^=(VQ L&, R);
1906 VQ L& operator|=(VQ L&, R); */
1907
1908 case MODIFY_EXPR:
1909 switch (code2)
1910 {
1911 case PLUS_EXPR:
1912 case MINUS_EXPR:
1913 if (TYPE_PTROB_P (type1) && INTEGRAL_TYPE_P (type2))
1914 {
1915 type2 = ptrdiff_type_node;
1916 break;
1917 }
1918 case MULT_EXPR:
1919 case TRUNC_DIV_EXPR:
1920 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1921 break;
1922 return;
1923
1924 case TRUNC_MOD_EXPR:
1925 case BIT_AND_EXPR:
1926 case BIT_IOR_EXPR:
1927 case BIT_XOR_EXPR:
1928 case LSHIFT_EXPR:
1929 case RSHIFT_EXPR:
1930 if (INTEGRAL_TYPE_P (type1) && INTEGRAL_TYPE_P (type2))
1931 break;
1932 return;
1933
1934 case NOP_EXPR:
1935 if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
1936 break;
1937 if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
1938 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1939 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1940 || ((TYPE_PTRMEMFUNC_P (type1)
1941 || TREE_CODE (type1) == POINTER_TYPE)
1942 && null_ptr_cst_p (args[1])))
1943 {
1944 type2 = type1;
1945 break;
1946 }
1947 return;
1948
1949 default:
1950 gcc_unreachable ();
1951 }
1952 type1 = build_reference_type (type1);
1953 break;
1954
1955 case COND_EXPR:
1956 /* [over.built]
1957
1958 For every pair of promoted arithmetic types L and R, there
1959 exist candidate operator functions of the form
1960
1961 LR operator?(bool, L, R);
1962
1963 where LR is the result of the usual arithmetic conversions
1964 between types L and R.
1965
1966 For every type T, where T is a pointer or pointer-to-member
1967 type, there exist candidate operator functions of the form T
1968 operator?(bool, T, T); */
1969
1970 if (promoted_arithmetic_type_p (type1)
1971 && promoted_arithmetic_type_p (type2))
1972 /* That's OK. */
1973 break;
1974
1975 /* Otherwise, the types should be pointers. */
1976 if (!(TYPE_PTR_P (type1) || TYPE_PTR_TO_MEMBER_P (type1))
1977 || !(TYPE_PTR_P (type2) || TYPE_PTR_TO_MEMBER_P (type2)))
1978 return;
1979
1980 /* We don't check that the two types are the same; the logic
1981 below will actually create two candidates; one in which both
1982 parameter types are TYPE1, and one in which both parameter
1983 types are TYPE2. */
1984 break;
1985
1986 default:
1987 gcc_unreachable ();
1988 }
1989
1990 /* If we're dealing with two pointer types or two enumeral types,
1991 we need candidates for both of them. */
1992 if (type2 && !same_type_p (type1, type2)
1993 && TREE_CODE (type1) == TREE_CODE (type2)
1994 && (TREE_CODE (type1) == REFERENCE_TYPE
1995 || (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
1996 || (TYPE_PTRMEM_P (type1) && TYPE_PTRMEM_P (type2))
1997 || TYPE_PTRMEMFUNC_P (type1)
1998 || IS_AGGR_TYPE (type1)
1999 || TREE_CODE (type1) == ENUMERAL_TYPE))
2000 {
2001 build_builtin_candidate
2002 (candidates, fnname, type1, type1, args, argtypes, flags);
2003 build_builtin_candidate
2004 (candidates, fnname, type2, type2, args, argtypes, flags);
2005 return;
2006 }
2007
2008 build_builtin_candidate
2009 (candidates, fnname, type1, type2, args, argtypes, flags);
2010}
2011
2012tree
2013type_decays_to (tree type)
2014{
2015 if (TREE_CODE (type) == ARRAY_TYPE)
2016 return build_pointer_type (TREE_TYPE (type));
2017 if (TREE_CODE (type) == FUNCTION_TYPE)
2018 return build_pointer_type (type);
2019 return type;
2020}
2021
2022/* There are three conditions of builtin candidates:
2023
2024 1) bool-taking candidates. These are the same regardless of the input.
2025 2) pointer-pair taking candidates. These are generated for each type
2026 one of the input types converts to.
2027 3) arithmetic candidates. According to the standard, we should generate
2028 all of these, but I'm trying not to...
2029
2030 Here we generate a superset of the possible candidates for this particular
2031 case. That is a subset of the full set the standard defines, plus some
2032 other cases which the standard disallows. add_builtin_candidate will
2033 filter out the invalid set. */
2034
2035static void
2036add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
2037 enum tree_code code2, tree fnname, tree *args,
2038 int flags)
2039{
2040 int ref1, i;
2041 int enum_p = 0;
2042 tree type, argtypes[3];
2043 /* TYPES[i] is the set of possible builtin-operator parameter types
2044 we will consider for the Ith argument. These are represented as
2045 a TREE_LIST; the TREE_VALUE of each node is the potential
2046 parameter type. */
2047 tree types[2];
2048
2049 for (i = 0; i < 3; ++i)
2050 {
2051 if (args[i])
2052 argtypes[i] = lvalue_type (args[i]);
2053 else
2054 argtypes[i] = NULL_TREE;
2055 }
2056
2057 switch (code)
2058 {
2059/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type,
2060 and VQ is either volatile or empty, there exist candidate operator
2061 functions of the form
2062 VQ T& operator++(VQ T&); */
2063
2064 case POSTINCREMENT_EXPR:
2065 case PREINCREMENT_EXPR:
2066 case POSTDECREMENT_EXPR:
2067 case PREDECREMENT_EXPR:
2068 case MODIFY_EXPR:
2069 ref1 = 1;
2070 break;
2071
2072/* 24There also exist candidate operator functions of the form
2073 bool operator!(bool);
2074 bool operator&&(bool, bool);
2075 bool operator||(bool, bool); */
2076
2077 case TRUTH_NOT_EXPR:
2078 build_builtin_candidate
2079 (candidates, fnname, boolean_type_node,
2080 NULL_TREE, args, argtypes, flags);
2081 return;
2082
2083 case TRUTH_ORIF_EXPR:
2084 case TRUTH_ANDIF_EXPR:
2085 build_builtin_candidate
2086 (candidates, fnname, boolean_type_node,
2087 boolean_type_node, args, argtypes, flags);
2088 return;
2089
2090 case ADDR_EXPR:
2091 case COMPOUND_EXPR:
2092 case COMPONENT_REF:
2093 return;
2094
2095 case COND_EXPR:
2096 case EQ_EXPR:
2097 case NE_EXPR:
2098 case LT_EXPR:
2099 case LE_EXPR:
2100 case GT_EXPR:
2101 case GE_EXPR:
2102 enum_p = 1;
2103 /* Fall through. */
2104
2105 default:
2106 ref1 = 0;
2107 }
2108
2109 types[0] = types[1] = NULL_TREE;
2110
2111 for (i = 0; i < 2; ++i)
2112 {
2113 if (! args[i])
2114 ;
2115 else if (IS_AGGR_TYPE (argtypes[i]))
2116 {
2117 tree convs;
2118
2119 if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
2120 return;
2121
2122 convs = lookup_conversions (argtypes[i]);
2123
2124 if (code == COND_EXPR)
2125 {
2126 if (real_lvalue_p (args[i]))
2127 types[i] = tree_cons
2128 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2129
2130 types[i] = tree_cons
2131 (NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
2132 }
2133
2134 else if (! convs)
2135 return;
2136
2137 for (; convs; convs = TREE_CHAIN (convs))
2138 {
2139 type = TREE_TYPE (TREE_TYPE (OVL_CURRENT (TREE_VALUE (convs))));
2140
2141 if (i == 0 && ref1
2142 && (TREE_CODE (type) != REFERENCE_TYPE
2143 || CP_TYPE_CONST_P (TREE_TYPE (type))))
2144 continue;
2145
2146 if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE)
2147 types[i] = tree_cons (NULL_TREE, type, types[i]);
2148
2149 type = non_reference (type);
2150 if (i != 0 || ! ref1)
2151 {
2152 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2153 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2154 types[i] = tree_cons (NULL_TREE, type, types[i]);
2155 if (INTEGRAL_TYPE_P (type))
2156 type = type_promotes_to (type);
2157 }
2158
2159 if (! value_member (type, types[i]))
2160 types[i] = tree_cons (NULL_TREE, type, types[i]);
2161 }
2162 }
2163 else
2164 {
2165 if (code == COND_EXPR && real_lvalue_p (args[i]))
2166 types[i] = tree_cons
2167 (NULL_TREE, build_reference_type (argtypes[i]), types[i]);
2168 type = non_reference (argtypes[i]);
2169 if (i != 0 || ! ref1)
2170 {
2171 type = TYPE_MAIN_VARIANT (type_decays_to (type));
2172 if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE)
2173 types[i] = tree_cons (NULL_TREE, type, types[i]);
2174 if (INTEGRAL_TYPE_P (type))
2175 type = type_promotes_to (type);
2176 }
2177 types[i] = tree_cons (NULL_TREE, type, types[i]);
2178 }
2179 }
2180
2181 /* Run through the possible parameter types of both arguments,
2182 creating candidates with those parameter types. */
2183 for (; types[0]; types[0] = TREE_CHAIN (types[0]))
2184 {
2185 if (types[1])
2186 for (type = types[1]; type; type = TREE_CHAIN (type))
2187 add_builtin_candidate
2188 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2189 TREE_VALUE (type), args, argtypes, flags);
2190 else
2191 add_builtin_candidate
2192 (candidates, code, code2, fnname, TREE_VALUE (types[0]),
2193 NULL_TREE, args, argtypes, flags);
2194 }
2195}
2196
2197
2198/* If TMPL can be successfully instantiated as indicated by
2199 EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES.
2200
2201 TMPL is the template. EXPLICIT_TARGS are any explicit template
2202 arguments. ARGLIST is the arguments provided at the call-site.
2203 The RETURN_TYPE is the desired type for conversion operators. If
2204 OBJ is NULL_TREE, FLAGS and CTYPE are as for add_function_candidate.
2205 If an OBJ is supplied, FLAGS and CTYPE are ignored, and OBJ is as for
2206 add_conv_candidate. */
2207
2208static struct z_candidate*
2209add_template_candidate_real (struct z_candidate **candidates, tree tmpl,
2210 tree ctype, tree explicit_targs, tree arglist,
2211 tree return_type, tree access_path,
2212 tree conversion_path, int flags, tree obj,
2213 unification_kind_t strict)
2214{
2215 int ntparms = DECL_NTPARMS (tmpl);
2216 tree targs = make_tree_vec (ntparms);
2217 tree args_without_in_chrg = arglist;
2218 struct z_candidate *cand;
2219 int i;
2220 tree fn;
2221
2222 /* We don't do deduction on the in-charge parameter, the VTT
2223 parameter or 'this'. */
2224 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl))
2225 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2226
2227 if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl)
2228 || DECL_BASE_CONSTRUCTOR_P (tmpl))
2229 && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl)))
2230 args_without_in_chrg = TREE_CHAIN (args_without_in_chrg);
2231
2232 i = fn_type_unification (tmpl, explicit_targs, targs,
2233 args_without_in_chrg,
2234 return_type, strict, flags);
2235
2236 if (i != 0)
2237 return NULL;
2238
2239 fn = instantiate_template (tmpl, targs, tf_none);
2240 if (fn == error_mark_node)
2241 return NULL;
2242
2243 /* In [class.copy]:
2244
2245 A member function template is never instantiated to perform the
2246 copy of a class object to an object of its class type.
2247
2248 It's a little unclear what this means; the standard explicitly
2249 does allow a template to be used to copy a class. For example,
2250 in:
2251
2252 struct A {
2253 A(A&);
2254 template <class T> A(const T&);
2255 };
2256 const A f ();
2257 void g () { A a (f ()); }
2258
2259 the member template will be used to make the copy. The section
2260 quoted above appears in the paragraph that forbids constructors
2261 whose only parameter is (a possibly cv-qualified variant of) the
2262 class type, and a logical interpretation is that the intent was
2263 to forbid the instantiation of member templates which would then
2264 have that form. */
2265 if (DECL_CONSTRUCTOR_P (fn) && list_length (arglist) == 2)
2266 {
2267 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
2268 if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)),
2269 ctype))
2270 return NULL;
2271 }
2272
2273 if (obj != NULL_TREE)
2274 /* Aha, this is a conversion function. */
2275 cand = add_conv_candidate (candidates, fn, obj, access_path,
2276 conversion_path, arglist);
2277 else
2278 cand = add_function_candidate (candidates, fn, ctype,
2279 arglist, access_path,
2280 conversion_path, flags);
2281 if (DECL_TI_TEMPLATE (fn) != tmpl)
2282 /* This situation can occur if a member template of a template
2283 class is specialized. Then, instantiate_template might return
2284 an instantiation of the specialization, in which case the
2285 DECL_TI_TEMPLATE field will point at the original
2286 specialization. For example:
2287
2288 template <class T> struct S { template <class U> void f(U);
2289 template <> void f(int) {}; };
2290 S<double> sd;
2291 sd.f(3);
2292
2293 Here, TMPL will be template <class U> S<double>::f(U).
2294 And, instantiate template will give us the specialization
2295 template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field
2296 for this will point at template <class T> template <> S<T>::f(int),
2297 so that we can find the definition. For the purposes of
2298 overload resolution, however, we want the original TMPL. */
2299 cand->template_decl = tree_cons (tmpl, targs, NULL_TREE);
2300 else
2301 cand->template_decl = DECL_TEMPLATE_INFO (fn);
2302
2303 return cand;
2304}
2305
2306
2307static struct z_candidate *
2308add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype,
2309 tree explicit_targs, tree arglist, tree return_type,
2310 tree access_path, tree conversion_path, int flags,
2311 unification_kind_t strict)
2312{
2313 return
2314 add_template_candidate_real (candidates, tmpl, ctype,
2315 explicit_targs, arglist, return_type,
2316 access_path, conversion_path,
2317 flags, NULL_TREE, strict);
2318}
2319
2320
2321static struct z_candidate *
2322add_template_conv_candidate (struct z_candidate **candidates, tree tmpl,
2323 tree obj, tree arglist, tree return_type,
2324 tree access_path, tree conversion_path)
2325{
2326 return
2327 add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE,
2328 arglist, return_type, access_path,
2329 conversion_path, 0, obj, DEDUCE_CONV);
2330}
2331
2332/* The CANDS are the set of candidates that were considered for
2333 overload resolution. Return the set of viable candidates. If none
2334 of the candidates were viable, set *ANY_VIABLE_P to true. STRICT_P
2335 is true if a candidate should be considered viable only if it is
2336 strictly viable. */
2337
2338static struct z_candidate*
2339splice_viable (struct z_candidate *cands,
2340 bool strict_p,
2341 bool *any_viable_p)
2342{
2343 struct z_candidate *viable;
2344 struct z_candidate **last_viable;
2345 struct z_candidate **cand;
2346
2347 viable = NULL;
2348 last_viable = &viable;
2349 *any_viable_p = false;
2350
2351 cand = &cands;
2352 while (*cand)
2353 {
2354 struct z_candidate *c = *cand;
2355 if (strict_p ? c->viable == 1 : c->viable)
2356 {
2357 *last_viable = c;
2358 *cand = c->next;
2359 c->next = NULL;
2360 last_viable = &c->next;
2361 *any_viable_p = true;
2362 }
2363 else
2364 cand = &c->next;
2365 }
2366
2367 return viable ? viable : cands;
2368}
2369
2370static bool
2371any_strictly_viable (struct z_candidate *cands)
2372{
2373 for (; cands; cands = cands->next)
2374 if (cands->viable == 1)
2375 return true;
2376 return false;
2377}
2378
2379/* OBJ is being used in an expression like "OBJ.f (...)". In other
2380 words, it is about to become the "this" pointer for a member
2381 function call. Take the address of the object. */
2382
2383static tree
2384build_this (tree obj)
2385{
2386 /* In a template, we are only concerned about the type of the
2387 expression, so we can take a shortcut. */
2388 if (processing_template_decl)
2389 return build_address (obj);
2390
2391 return build_unary_op (ADDR_EXPR, obj, 0);
2392}
2393
2394/* Returns true iff functions are equivalent. Equivalent functions are
2395 not '==' only if one is a function-local extern function or if
2396 both are extern "C". */
2397
2398static inline int
2399equal_functions (tree fn1, tree fn2)
2400{
2401 if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2)
2402 || DECL_EXTERN_C_FUNCTION_P (fn1))
2403 return decls_match (fn1, fn2);
2404 return fn1 == fn2;
2405}
2406
2407/* Print information about one overload candidate CANDIDATE. MSGSTR
2408 is the text to print before the candidate itself.
2409
2410 NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected
2411 to have been run through gettext by the caller. This wart makes
2412 life simpler in print_z_candidates and for the translators. */
2413
2414static void
2415print_z_candidate (const char *msgstr, struct z_candidate *candidate)
2416{
2417 if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE)
2418 {
2419 if (candidate->num_convs == 3)
2420 inform ("%s %D(%T, %T, %T) <built-in>", msgstr, candidate->fn,
2421 candidate->convs[0]->type,
2422 candidate->convs[1]->type,
2423 candidate->convs[2]->type);
2424 else if (candidate->num_convs == 2)
2425 inform ("%s %D(%T, %T) <built-in>", msgstr, candidate->fn,
2426 candidate->convs[0]->type,
2427 candidate->convs[1]->type);
2428 else
2429 inform ("%s %D(%T) <built-in>", msgstr, candidate->fn,
2430 candidate->convs[0]->type);
2431 }
2432 else if (TYPE_P (candidate->fn))
2433 inform ("%s %T <conversion>", msgstr, candidate->fn);
2434 else if (candidate->viable == -1)
2435 inform ("%s %+#D <near match>", msgstr, candidate->fn);
2436 else
2437 inform ("%s %+#D", msgstr, candidate->fn);
2438}
2439
2440static void
2441print_z_candidates (struct z_candidate *candidates)
2442{
2443 const char *str;
2444 struct z_candidate *cand1;
2445 struct z_candidate **cand2;
2446
2447 /* There may be duplicates in the set of candidates. We put off
2448 checking this condition as long as possible, since we have no way
2449 to eliminate duplicates from a set of functions in less than n^2
2450 time. Now we are about to emit an error message, so it is more
2451 permissible to go slowly. */
2452 for (cand1 = candidates; cand1; cand1 = cand1->next)
2453 {
2454 tree fn = cand1->fn;
2455 /* Skip builtin candidates and conversion functions. */
2456 if (TREE_CODE (fn) != FUNCTION_DECL)
2457 continue;
2458 cand2 = &cand1->next;
2459 while (*cand2)
2460 {
2461 if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL
2462 && equal_functions (fn, (*cand2)->fn))
2463 *cand2 = (*cand2)->next;
2464 else
2465 cand2 = &(*cand2)->next;
2466 }
2467 }
2468
2469 if (!candidates)
2470 return;
2471
2472 str = _("candidates are:");
2473 print_z_candidate (str, candidates);
2474 if (candidates->next)
2475 {
2476 /* Indent successive candidates by the width of the translation
2477 of the above string. */
2478 size_t len = gcc_gettext_width (str) + 1;
2479 char *spaces = (char *) alloca (len);
2480 memset (spaces, ' ', len-1);
2481 spaces[len - 1] = '\0';
2482
2483 candidates = candidates->next;
2484 do
2485 {
2486 print_z_candidate (spaces, candidates);
2487 candidates = candidates->next;
2488 }
2489 while (candidates);
2490 }
2491}
2492
2493/* USER_SEQ is a user-defined conversion sequence, beginning with a
2494 USER_CONV. STD_SEQ is the standard conversion sequence applied to
2495 the result of the conversion function to convert it to the final
2496 desired type. Merge the two sequences into a single sequence,
2497 and return the merged sequence. */
2498
2499static conversion *
2500merge_conversion_sequences (conversion *user_seq, conversion *std_seq)
2501{
2502 conversion **t;
2503
2504 gcc_assert (user_seq->kind == ck_user);
2505
2506 /* Find the end of the second conversion sequence. */
2507 t = &(std_seq);
2508 while ((*t)->kind != ck_identity)
2509 t = &((*t)->u.next);
2510
2511 /* Replace the identity conversion with the user conversion
2512 sequence. */
2513 *t = user_seq;
2514
2515 /* The entire sequence is a user-conversion sequence. */
2516 std_seq->user_conv_p = true;
2517
2518 return std_seq;
2519}
2520
2521/* Returns the best overload candidate to perform the requested
2522 conversion. This function is used for three the overloading situations
2523 described in [over.match.copy], [over.match.conv], and [over.match.ref].
2524 If TOTYPE is a REFERENCE_TYPE, we're trying to find an lvalue binding as
2525 per [dcl.init.ref], so we ignore temporary bindings. */
2526
2527static struct z_candidate *
2528build_user_type_conversion_1 (tree totype, tree expr, int flags)
2529{
2530 struct z_candidate *candidates, *cand;
2531 tree fromtype = TREE_TYPE (expr);
2532 tree ctors = NULL_TREE;
2533 tree conv_fns = NULL_TREE;
2534 conversion *conv = NULL;
2535 tree args = NULL_TREE;
2536 bool any_viable_p;
2537
2538 /* We represent conversion within a hierarchy using RVALUE_CONV and
2539 BASE_CONV, as specified by [over.best.ics]; these become plain
2540 constructor calls, as specified in [dcl.init]. */
2541 gcc_assert (!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)
2542 || !DERIVED_FROM_P (totype, fromtype));
2543
2544 if (IS_AGGR_TYPE (totype))
2545 ctors = lookup_fnfields (totype, complete_ctor_identifier, 0);
2546
2547 if (IS_AGGR_TYPE (fromtype))
2548 conv_fns = lookup_conversions (fromtype);
2549
2550 candidates = 0;
2551 flags |= LOOKUP_NO_CONVERSION;
2552
2553 if (ctors)
2554 {
2555 tree t;
2556
2557 ctors = BASELINK_FUNCTIONS (ctors);
2558
2559 t = build_int_cst (build_pointer_type (totype), 0);
2560 args = build_tree_list (NULL_TREE, expr);
2561 /* We should never try to call the abstract or base constructor
2562 from here. */
2563 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors))
2564 && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)));
2565 args = tree_cons (NULL_TREE, t, args);
2566 }
2567 for (; ctors; ctors = OVL_NEXT (ctors))
2568 {
2569 tree ctor = OVL_CURRENT (ctors);
2570 if (DECL_NONCONVERTING_P (ctor))
2571 continue;
2572
2573 if (TREE_CODE (ctor) == TEMPLATE_DECL)
2574 cand = add_template_candidate (&candidates, ctor, totype,
2575 NULL_TREE, args, NULL_TREE,
2576 TYPE_BINFO (totype),
2577 TYPE_BINFO (totype),
2578 flags,
2579 DEDUCE_CALL);
2580 else
2581 cand = add_function_candidate (&candidates, ctor, totype,
2582 args, TYPE_BINFO (totype),
2583 TYPE_BINFO (totype),
2584 flags);
2585
2586 if (cand)
2587 cand->second_conv = build_identity_conv (totype, NULL_TREE);
2588 }
2589
2590 if (conv_fns)
2591 args = build_tree_list (NULL_TREE, build_this (expr));
2592
2593 for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns))
2594 {
2595 tree fns;
2596 tree conversion_path = TREE_PURPOSE (conv_fns);
2597 int convflags = LOOKUP_NO_CONVERSION;
2598
2599 /* If we are called to convert to a reference type, we are trying to
2600 find an lvalue binding, so don't even consider temporaries. If
2601 we don't find an lvalue binding, the caller will try again to
2602 look for a temporary binding. */
2603 if (TREE_CODE (totype) == REFERENCE_TYPE)
2604 convflags |= LOOKUP_NO_TEMP_BIND;
2605
2606 for (fns = TREE_VALUE (conv_fns); fns; fns = OVL_NEXT (fns))
2607 {
2608 tree fn = OVL_CURRENT (fns);
2609
2610 /* [over.match.funcs] For conversion functions, the function
2611 is considered to be a member of the class of the implicit
2612 object argument for the purpose of defining the type of
2613 the implicit object parameter.
2614
2615 So we pass fromtype as CTYPE to add_*_candidate. */
2616
2617 if (TREE_CODE (fn) == TEMPLATE_DECL)
2618 cand = add_template_candidate (&candidates, fn, fromtype,
2619 NULL_TREE,
2620 args, totype,
2621 TYPE_BINFO (fromtype),
2622 conversion_path,
2623 flags,
2624 DEDUCE_CONV);
2625 else
2626 cand = add_function_candidate (&candidates, fn, fromtype,
2627 args,
2628 TYPE_BINFO (fromtype),
2629 conversion_path,
2630 flags);
2631
2632 if (cand)
2633 {
2634 conversion *ics
2635 = implicit_conversion (totype,
2636 TREE_TYPE (TREE_TYPE (cand->fn)),
2637 0,
2638 /*c_cast_p=*/false, convflags);
2639
2640 cand->second_conv = ics;
2641
2642 if (!ics)
2643 cand->viable = 0;
2644 else if (candidates->viable == 1 && ics->bad_p)
2645 cand->viable = -1;
2646 }
2647 }
2648 }
2649
2650 candidates = splice_viable (candidates, pedantic, &any_viable_p);
2651 if (!any_viable_p)
2652 return NULL;
2653
2654 cand = tourney (candidates);
2655 if (cand == 0)
2656 {
2657 if (flags & LOOKUP_COMPLAIN)
2658 {
2659 error ("conversion from %qT to %qT is ambiguous",
2660 fromtype, totype);
2661 print_z_candidates (candidates);
2662 }
2663
2664 cand = candidates; /* any one will do */
2665 cand->second_conv = build_ambiguous_conv (totype, expr);
2666 cand->second_conv->user_conv_p = true;
2667 if (!any_strictly_viable (candidates))
2668 cand->second_conv->bad_p = true;
2669 /* If there are viable candidates, don't set ICS_BAD_FLAG; an
2670 ambiguous conversion is no worse than another user-defined
2671 conversion. */
2672
2673 return cand;
2674 }
2675
2676 /* Build the user conversion sequence. */
2677 conv = build_conv
2678 (ck_user,
2679 (DECL_CONSTRUCTOR_P (cand->fn)
2680 ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))),
2681 build_identity_conv (TREE_TYPE (expr), expr));
2682 conv->cand = cand;
2683
2684 /* Combine it with the second conversion sequence. */
2685 cand->second_conv = merge_conversion_sequences (conv,
2686 cand->second_conv);
2687
2688 if (cand->viable == -1)
2689 cand->second_conv->bad_p = true;
2690
2691 return cand;
2692}
2693
2694tree
2695build_user_type_conversion (tree totype, tree expr, int flags)
2696{
2697 struct z_candidate *cand
2698 = build_user_type_conversion_1 (totype, expr, flags);
2699
2700 if (cand)
2701 {
2702 if (cand->second_conv->kind == ck_ambig)
2703 return error_mark_node;
2704 expr = convert_like (cand->second_conv, expr);
2705 return convert_from_reference (expr);
2706 }
2707 return NULL_TREE;
2708}
2709
2710/* Do any initial processing on the arguments to a function call. */
2711
2712static tree
2713resolve_args (tree args)
2714{
2715 tree t;
2716 for (t = args; t; t = TREE_CHAIN (t))
2717 {
2718 tree arg = TREE_VALUE (t);
2719
2720 if (error_operand_p (arg))
2721 return error_mark_node;
2722 else if (VOID_TYPE_P (TREE_TYPE (arg)))
2723 {
2724 error ("invalid use of void expression");
2725 return error_mark_node;
2726 }
2727 else if (invalid_nonstatic_memfn_p (arg))
2728 return error_mark_node;
2729 }
2730 return args;
2731}
2732
2733/* Perform overload resolution on FN, which is called with the ARGS.
2734
2735 Return the candidate function selected by overload resolution, or
2736 NULL if the event that overload resolution failed. In the case
2737 that overload resolution fails, *CANDIDATES will be the set of
2738 candidates considered, and ANY_VIABLE_P will be set to true or
2739 false to indicate whether or not any of the candidates were
2740 viable.
2741
2742 The ARGS should already have gone through RESOLVE_ARGS before this
2743 function is called. */
2744
2745static struct z_candidate *
2746perform_overload_resolution (tree fn,
2747 tree args,
2748 struct z_candidate **candidates,
2749 bool *any_viable_p)
2750{
2751 struct z_candidate *cand;
2752 tree explicit_targs = NULL_TREE;
2753 int template_only = 0;
2754
2755 *candidates = NULL;
2756 *any_viable_p = true;
2757
2758 /* Check FN and ARGS. */
2759 gcc_assert (TREE_CODE (fn) == FUNCTION_DECL
2760 || TREE_CODE (fn) == TEMPLATE_DECL
2761 || TREE_CODE (fn) == OVERLOAD
2762 || TREE_CODE (fn) == TEMPLATE_ID_EXPR);
2763 gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
2764
2765 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2766 {
2767 explicit_targs = TREE_OPERAND (fn, 1);
2768 fn = TREE_OPERAND (fn, 0);
2769 template_only = 1;
2770 }
2771
2772 /* Add the various candidate functions. */
2773 add_candidates (fn, args, explicit_targs, template_only,
2774 /*conversion_path=*/NULL_TREE,
2775 /*access_path=*/NULL_TREE,
2776 LOOKUP_NORMAL,
2777 candidates);
2778
2779 *candidates = splice_viable (*candidates, pedantic, any_viable_p);
2780 if (!*any_viable_p)
2781 return NULL;
2782
2783 cand = tourney (*candidates);
2784 return cand;
2785}
2786
2787/* Return an expression for a call to FN (a namespace-scope function,
2788 or a static member function) with the ARGS. */
2789
2790tree
2791build_new_function_call (tree fn, tree args, bool koenig_p)
2792{
2793 struct z_candidate *candidates, *cand;
2794 bool any_viable_p;
2795 void *p;
2796 tree result;
2797
2798 args = resolve_args (args);
2799 if (args == error_mark_node)
2800 return error_mark_node;
2801
2802 /* If this function was found without using argument dependent
2803 lookup, then we want to ignore any undeclared friend
2804 functions. */
2805 if (!koenig_p)
2806 {
2807 tree orig_fn = fn;
2808
2809 fn = remove_hidden_names (fn);
2810 if (!fn)
2811 {
2812 error ("no matching function for call to %<%D(%A)%>",
2813 DECL_NAME (OVL_CURRENT (orig_fn)), args);
2814 return error_mark_node;
2815 }
2816 }
2817
2818 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2819 p = conversion_obstack_alloc (0);
2820
2821 cand = perform_overload_resolution (fn, args, &candidates, &any_viable_p);
2822
2823 if (!cand)
2824 {
2825 if (!any_viable_p && candidates && ! candidates->next)
2826 return build_function_call (candidates->fn, args);
2827 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
2828 fn = TREE_OPERAND (fn, 0);
2829 if (!any_viable_p)
2830 error ("no matching function for call to %<%D(%A)%>",
2831 DECL_NAME (OVL_CURRENT (fn)), args);
2832 else
2833 error ("call of overloaded %<%D(%A)%> is ambiguous",
2834 DECL_NAME (OVL_CURRENT (fn)), args);
2835 if (candidates)
2836 print_z_candidates (candidates);
2837 result = error_mark_node;
2838 }
2839 else
2840 result = build_over_call (cand, LOOKUP_NORMAL);
2841
2842 /* Free all the conversions we allocated. */
2843 obstack_free (&conversion_obstack, p);
2844
2845 return result;
2846}
2847
2848/* Build a call to a global operator new. FNNAME is the name of the
2849 operator (either "operator new" or "operator new[]") and ARGS are
2850 the arguments provided. *SIZE points to the total number of bytes
2851 required by the allocation, and is updated if that is changed here.
2852 *COOKIE_SIZE is non-NULL if a cookie should be used. If this
2853 function determines that no cookie should be used, after all,
2854 *COOKIE_SIZE is set to NULL_TREE. If FN is non-NULL, it will be
2855 set, upon return, to the allocation function called. */
2856
2857tree
2858build_operator_new_call (tree fnname, tree args,
2859 tree *size, tree *cookie_size,
2860 tree *fn)
2861{
2862 tree fns;
2863 struct z_candidate *candidates;
2864 struct z_candidate *cand;
2865 bool any_viable_p;
2866
2867 if (fn)
2868 *fn = NULL_TREE;
2869 args = tree_cons (NULL_TREE, *size, args);
2870 args = resolve_args (args);
2871 if (args == error_mark_node)
2872 return args;
2873
2874 /* Based on:
2875
2876 [expr.new]
2877
2878 If this lookup fails to find the name, or if the allocated type
2879 is not a class type, the allocation function's name is looked
2880 up in the global scope.
2881
2882 we disregard block-scope declarations of "operator new". */
2883 fns = lookup_function_nonclass (fnname, args, /*block_p=*/false);
2884
2885 /* Figure out what function is being called. */
2886 cand = perform_overload_resolution (fns, args, &candidates, &any_viable_p);
2887
2888 /* If no suitable function could be found, issue an error message
2889 and give up. */
2890 if (!cand)
2891 {
2892 if (!any_viable_p)
2893 error ("no matching function for call to %<%D(%A)%>",
2894 DECL_NAME (OVL_CURRENT (fns)), args);
2895 else
2896 error ("call of overloaded %<%D(%A)%> is ambiguous",
2897 DECL_NAME (OVL_CURRENT (fns)), args);
2898 if (candidates)
2899 print_z_candidates (candidates);
2900 return error_mark_node;
2901 }
2902
2903 /* If a cookie is required, add some extra space. Whether
2904 or not a cookie is required cannot be determined until
2905 after we know which function was called. */
2906 if (*cookie_size)
2907 {
2908 bool use_cookie = true;
2909 if (!abi_version_at_least (2))
2910 {
2911 tree placement = TREE_CHAIN (args);
2912 /* In G++ 3.2, the check was implemented incorrectly; it
2913 looked at the placement expression, rather than the
2914 type of the function. */
2915 if (placement && !TREE_CHAIN (placement)
2916 && same_type_p (TREE_TYPE (TREE_VALUE (placement)),
2917 ptr_type_node))
2918 use_cookie = false;
2919 }
2920 else
2921 {
2922 tree arg_types;
2923
2924 arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn));
2925 /* Skip the size_t parameter. */
2926 arg_types = TREE_CHAIN (arg_types);
2927 /* Check the remaining parameters (if any). */
2928 if (arg_types
2929 && TREE_CHAIN (arg_types) == void_list_node
2930 && same_type_p (TREE_VALUE (arg_types),
2931 ptr_type_node))
2932 use_cookie = false;
2933 }
2934 /* If we need a cookie, adjust the number of bytes allocated. */
2935 if (use_cookie)
2936 {
2937 /* Update the total size. */
2938 *size = size_binop (PLUS_EXPR, *size, *cookie_size);
2939 /* Update the argument list to reflect the adjusted size. */
2940 TREE_VALUE (args) = *size;
2941 }
2942 else
2943 *cookie_size = NULL_TREE;
2944 }
2945
2946 /* Tell our caller which function we decided to call. */
2947 if (fn)
2948 *fn = cand->fn;
2949
2950 /* Build the CALL_EXPR. */
2951 return build_over_call (cand, LOOKUP_NORMAL);
2952}
2953
2954static tree
2955build_object_call (tree obj, tree args)
2956{
2957 struct z_candidate *candidates = 0, *cand;
2958 tree fns, convs, mem_args = NULL_TREE;
2959 tree type = TREE_TYPE (obj);
2960 bool any_viable_p;
2961 tree result = NULL_TREE;
2962 void *p;
2963
2964 if (TYPE_PTRMEMFUNC_P (type))
2965 {
2966 /* It's no good looking for an overloaded operator() on a
2967 pointer-to-member-function. */
2968 error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj);
2969 return error_mark_node;
2970 }
2971
2972 if (TYPE_BINFO (type))
2973 {
2974 fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1);
2975 if (fns == error_mark_node)
2976 return error_mark_node;
2977 }
2978 else
2979 fns = NULL_TREE;
2980
2981 args = resolve_args (args);
2982
2983 if (args == error_mark_node)
2984 return error_mark_node;
2985
2986 /* Get the high-water mark for the CONVERSION_OBSTACK. */
2987 p = conversion_obstack_alloc (0);
2988
2989 if (fns)
2990 {
2991 tree base = BINFO_TYPE (BASELINK_BINFO (fns));
2992 mem_args = tree_cons (NULL_TREE, build_this (obj), args);
2993
2994 for (fns = BASELINK_FUNCTIONS (fns); fns; fns = OVL_NEXT (fns))
2995 {
2996 tree fn = OVL_CURRENT (fns);
2997 if (TREE_CODE (fn) == TEMPLATE_DECL)
2998 add_template_candidate (&candidates, fn, base, NULL_TREE,
2999 mem_args, NULL_TREE,
3000 TYPE_BINFO (type),
3001 TYPE_BINFO (type),
3002 LOOKUP_NORMAL, DEDUCE_CALL);
3003 else
3004 add_function_candidate
3005 (&candidates, fn, base, mem_args, TYPE_BINFO (type),
3006 TYPE_BINFO (type), LOOKUP_NORMAL);
3007 }
3008 }
3009
3010 convs = lookup_conversions (type);
3011
3012 for (; convs; convs = TREE_CHAIN (convs))
3013 {
3014 tree fns = TREE_VALUE (convs);
3015 tree totype = TREE_TYPE (TREE_TYPE (OVL_CURRENT (fns)));
3016
3017 if ((TREE_CODE (totype) == POINTER_TYPE
3018 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3019 || (TREE_CODE (totype) == REFERENCE_TYPE
3020 && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE)
3021 || (TREE_CODE (totype) == REFERENCE_TYPE
3022 && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE
3023 && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE))
3024 for (; fns; fns = OVL_NEXT (fns))
3025 {
3026 tree fn = OVL_CURRENT (fns);
3027 if (TREE_CODE (fn) == TEMPLATE_DECL)
3028 add_template_conv_candidate
3029 (&candidates, fn, obj, args, totype,
3030 /*access_path=*/NULL_TREE,
3031 /*conversion_path=*/NULL_TREE);
3032 else
3033 add_conv_candidate (&candidates, fn, obj, args,
3034 /*conversion_path=*/NULL_TREE,
3035 /*access_path=*/NULL_TREE);
3036 }
3037 }
3038
3039 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3040 if (!any_viable_p)
3041 {
3042 error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args);
3043 print_z_candidates (candidates);
3044 result = error_mark_node;
3045 }
3046 else
3047 {
3048 cand = tourney (candidates);
3049 if (cand == 0)
3050 {
3051 error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args);
3052 print_z_candidates (candidates);
3053 result = error_mark_node;
3054 }
3055 /* Since cand->fn will be a type, not a function, for a conversion
3056 function, we must be careful not to unconditionally look at
3057 DECL_NAME here. */
3058 else if (TREE_CODE (cand->fn) == FUNCTION_DECL
3059 && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
3060 result = build_over_call (cand, LOOKUP_NORMAL);
3061 else
3062 {
3063 obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1);
3064 obj = convert_from_reference (obj);
3065 result = build_function_call (obj, args);
3066 }
3067 }
3068
3069 /* Free all the conversions we allocated. */
3070 obstack_free (&conversion_obstack, p);
3071
3072 return result;
3073}
3074
3075static void
3076op_error (enum tree_code code, enum tree_code code2,
3077 tree arg1, tree arg2, tree arg3, const char *problem)
3078{
3079 const char *opname;
3080
3081 if (code == MODIFY_EXPR)
3082 opname = assignment_operator_name_info[code2].name;
3083 else
3084 opname = operator_name_info[code].name;
3085
3086 switch (code)
3087 {
3088 case COND_EXPR:
3089 error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>",
3090 problem, arg1, arg2, arg3);
3091 break;
3092
3093 case POSTINCREMENT_EXPR:
3094 case POSTDECREMENT_EXPR:
3095 error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname);
3096 break;
3097
3098 case ARRAY_REF:
3099 error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2);
3100 break;
3101
3102 case REALPART_EXPR:
3103 case IMAGPART_EXPR:
3104 error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1);
3105 break;
3106
3107 default:
3108 if (arg2)
3109 error ("%s for %<operator%s%> in %<%E %s %E%>",
3110 problem, opname, arg1, opname, arg2);
3111 else
3112 error ("%s for %<operator%s%> in %<%s%E%>",
3113 problem, opname, opname, arg1);
3114 break;
3115 }
3116}
3117
3118/* Return the implicit conversion sequence that could be used to
3119 convert E1 to E2 in [expr.cond]. */
3120
3121static conversion *
3122conditional_conversion (tree e1, tree e2)
3123{
3124 tree t1 = non_reference (TREE_TYPE (e1));
3125 tree t2 = non_reference (TREE_TYPE (e2));
3126 conversion *conv;
3127 bool good_base;
3128
3129 /* [expr.cond]
3130
3131 If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
3132 implicitly converted (clause _conv_) to the type "reference to
3133 T2", subject to the constraint that in the conversion the
3134 reference must bind directly (_dcl.init.ref_) to E1. */
3135 if (real_lvalue_p (e2))
3136 {
3137 conv = implicit_conversion (build_reference_type (t2),
3138 t1,
3139 e1,
3140 /*c_cast_p=*/false,
3141 LOOKUP_NO_TEMP_BIND);
3142 if (conv)
3143 return conv;
3144 }
3145
3146 /* [expr.cond]
3147
3148 If E1 and E2 have class type, and the underlying class types are
3149 the same or one is a base class of the other: E1 can be converted
3150 to match E2 if the class of T2 is the same type as, or a base
3151 class of, the class of T1, and the cv-qualification of T2 is the
3152 same cv-qualification as, or a greater cv-qualification than, the
3153 cv-qualification of T1. If the conversion is applied, E1 is
3154 changed to an rvalue of type T2 that still refers to the original
3155 source class object (or the appropriate subobject thereof). */
3156 if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
3157 && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2)))
3158 {
3159 if (good_base && at_least_as_qualified_p (t2, t1))
3160 {
3161 conv = build_identity_conv (t1, e1);
3162 if (!same_type_p (TYPE_MAIN_VARIANT (t1),
3163 TYPE_MAIN_VARIANT (t2)))
3164 conv = build_conv (ck_base, t2, conv);
3165 else
3166 conv = build_conv (ck_rvalue, t2, conv);
3167 return conv;
3168 }
3169 else
3170 return NULL;
3171 }
3172 else
3173 /* [expr.cond]
3174
3175 Otherwise: E1 can be converted to match E2 if E1 can be implicitly
3176 converted to the type that expression E2 would have if E2 were
3177 converted to an rvalue (or the type it has, if E2 is an rvalue). */
3178 return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false,
3179 LOOKUP_NORMAL);
3180}
3181
3182/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three
3183 arguments to the conditional expression. */
3184
3185tree
3186build_conditional_expr (tree arg1, tree arg2, tree arg3)
3187{
3188 tree arg2_type;
3189 tree arg3_type;
3190 tree result = NULL_TREE;
3191 tree result_type = NULL_TREE;
3192 bool lvalue_p = true;
3193 struct z_candidate *candidates = 0;
3194 struct z_candidate *cand;
3195 void *p;
3196
3197 /* As a G++ extension, the second argument to the conditional can be
3198 omitted. (So that `a ? : c' is roughly equivalent to `a ? a :
3199 c'.) If the second operand is omitted, make sure it is
3200 calculated only once. */
3201 if (!arg2)
3202 {
3203 if (pedantic)
3204 pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression");
3205
3206 /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */
3207 if (real_lvalue_p (arg1))
3208 arg2 = arg1 = stabilize_reference (arg1);
3209 else
3210 arg2 = arg1 = save_expr (arg1);
3211 }
3212
3213 /* [expr.cond]
3214
3215 The first expr ession is implicitly converted to bool (clause
3216 _conv_). */
3217 arg1 = perform_implicit_conversion (boolean_type_node, arg1);
3218
3219 /* If something has already gone wrong, just pass that fact up the
3220 tree. */
3221 if (error_operand_p (arg1)
3222 || error_operand_p (arg2)
3223 || error_operand_p (arg3))
3224 return error_mark_node;
3225
3226 /* [expr.cond]
3227
3228 If either the second or the third operand has type (possibly
3229 cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_),
3230 array-to-pointer (_conv.array_), and function-to-pointer
3231 (_conv.func_) standard conversions are performed on the second
3232 and third operands. */
3233 arg2_type = unlowered_expr_type (arg2);
3234 arg3_type = unlowered_expr_type (arg3);
3235 if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type))
3236 {
3237 /* Do the conversions. We don't these for `void' type arguments
3238 since it can't have any effect and since decay_conversion
3239 does not handle that case gracefully. */
3240 if (!VOID_TYPE_P (arg2_type))
3241 arg2 = decay_conversion (arg2);
3242 if (!VOID_TYPE_P (arg3_type))
3243 arg3 = decay_conversion (arg3);
3244 arg2_type = TREE_TYPE (arg2);
3245 arg3_type = TREE_TYPE (arg3);
3246
3247 /* [expr.cond]
3248
3249 One of the following shall hold:
3250
3251 --The second or the third operand (but not both) is a
3252 throw-expression (_except.throw_); the result is of the
3253 type of the other and is an rvalue.
3254
3255 --Both the second and the third operands have type void; the
3256 result is of type void and is an rvalue.
3257
3258 We must avoid calling force_rvalue for expressions of type
3259 "void" because it will complain that their value is being
3260 used. */
3261 if (TREE_CODE (arg2) == THROW_EXPR
3262 && TREE_CODE (arg3) != THROW_EXPR)
3263 {
3264 if (!VOID_TYPE_P (arg3_type))
3265 arg3 = force_rvalue (arg3);
3266 arg3_type = TREE_TYPE (arg3);
3267 result_type = arg3_type;
3268 }
3269 else if (TREE_CODE (arg2) != THROW_EXPR
3270 && TREE_CODE (arg3) == THROW_EXPR)
3271 {
3272 if (!VOID_TYPE_P (arg2_type))
3273 arg2 = force_rvalue (arg2);
3274 arg2_type = TREE_TYPE (arg2);
3275 result_type = arg2_type;
3276 }
3277 else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type))
3278 result_type = void_type_node;
3279 else
3280 {
3281 error ("%qE has type %<void%> and is not a throw-expression",
3282 VOID_TYPE_P (arg2_type) ? arg2 : arg3);
3283 return error_mark_node;
3284 }
3285
3286 lvalue_p = false;
3287 goto valid_operands;
3288 }
3289 /* [expr.cond]
3290
3291 Otherwise, if the second and third operand have different types,
3292 and either has (possibly cv-qualified) class type, an attempt is
3293 made to convert each of those operands to the type of the other. */
3294 else if (!same_type_p (arg2_type, arg3_type)
3295 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3296 {
3297 conversion *conv2;
3298 conversion *conv3;
3299
3300 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3301 p = conversion_obstack_alloc (0);
3302
3303 conv2 = conditional_conversion (arg2, arg3);
3304 conv3 = conditional_conversion (arg3, arg2);
3305
3306 /* [expr.cond]
3307
3308 If both can be converted, or one can be converted but the
3309 conversion is ambiguous, the program is ill-formed. If
3310 neither can be converted, the operands are left unchanged and
3311 further checking is performed as described below. If exactly
3312 one conversion is possible, that conversion is applied to the
3313 chosen operand and the converted operand is used in place of
3314 the original operand for the remainder of this section. */
3315 if ((conv2 && !conv2->bad_p
3316 && conv3 && !conv3->bad_p)
3317 || (conv2 && conv2->kind == ck_ambig)
3318 || (conv3 && conv3->kind == ck_ambig))
3319 {
3320 error ("operands to ?: have different types %qT and %qT",
3321 arg2_type, arg3_type);
3322 result = error_mark_node;
3323 }
3324 else if (conv2 && (!conv2->bad_p || !conv3))
3325 {
3326 arg2 = convert_like (conv2, arg2);
3327 arg2 = convert_from_reference (arg2);
3328 arg2_type = TREE_TYPE (arg2);
3329 /* Even if CONV2 is a valid conversion, the result of the
3330 conversion may be invalid. For example, if ARG3 has type
3331 "volatile X", and X does not have a copy constructor
3332 accepting a "volatile X&", then even if ARG2 can be
3333 converted to X, the conversion will fail. */
3334 if (error_operand_p (arg2))
3335 result = error_mark_node;
3336 }
3337 else if (conv3 && (!conv3->bad_p || !conv2))
3338 {
3339 arg3 = convert_like (conv3, arg3);
3340 arg3 = convert_from_reference (arg3);
3341 arg3_type = TREE_TYPE (arg3);
3342 if (error_operand_p (arg3))
3343 result = error_mark_node;
3344 }
3345
3346 /* Free all the conversions we allocated. */
3347 obstack_free (&conversion_obstack, p);
3348
3349 if (result)
3350 return result;
3351
3352 /* If, after the conversion, both operands have class type,
3353 treat the cv-qualification of both operands as if it were the
3354 union of the cv-qualification of the operands.
3355
3356 The standard is not clear about what to do in this
3357 circumstance. For example, if the first operand has type
3358 "const X" and the second operand has a user-defined
3359 conversion to "volatile X", what is the type of the second
3360 operand after this step? Making it be "const X" (matching
3361 the first operand) seems wrong, as that discards the
3362 qualification without actually performing a copy. Leaving it
3363 as "volatile X" seems wrong as that will result in the
3364 conditional expression failing altogether, even though,
3365 according to this step, the one operand could be converted to
3366 the type of the other. */
3367 if ((conv2 || conv3)
3368 && CLASS_TYPE_P (arg2_type)
3369 && TYPE_QUALS (arg2_type) != TYPE_QUALS (arg3_type))
3370 arg2_type = arg3_type =
3371 cp_build_qualified_type (arg2_type,
3372 TYPE_QUALS (arg2_type)
3373 | TYPE_QUALS (arg3_type));
3374 }
3375
3376 /* [expr.cond]
3377
3378 If the second and third operands are lvalues and have the same
3379 type, the result is of that type and is an lvalue. */
3380 if (real_lvalue_p (arg2)
3381 && real_lvalue_p (arg3)
3382 && same_type_p (arg2_type, arg3_type))
3383 {
3384 result_type = arg2_type;
3385 goto valid_operands;
3386 }
3387
3388 /* [expr.cond]
3389
3390 Otherwise, the result is an rvalue. If the second and third
3391 operand do not have the same type, and either has (possibly
3392 cv-qualified) class type, overload resolution is used to
3393 determine the conversions (if any) to be applied to the operands
3394 (_over.match.oper_, _over.built_). */
3395 lvalue_p = false;
3396 if (!same_type_p (arg2_type, arg3_type)
3397 && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type)))
3398 {
3399 tree args[3];
3400 conversion *conv;
3401 bool any_viable_p;
3402
3403 /* Rearrange the arguments so that add_builtin_candidate only has
3404 to know about two args. In build_builtin_candidates, the
3405 arguments are unscrambled. */
3406 args[0] = arg2;
3407 args[1] = arg3;
3408 args[2] = arg1;
3409 add_builtin_candidates (&candidates,
3410 COND_EXPR,
3411 NOP_EXPR,
3412 ansi_opname (COND_EXPR),
3413 args,
3414 LOOKUP_NORMAL);
3415
3416 /* [expr.cond]
3417
3418 If the overload resolution fails, the program is
3419 ill-formed. */
3420 candidates = splice_viable (candidates, pedantic, &any_viable_p);
3421 if (!any_viable_p)
3422 {
3423 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3424 print_z_candidates (candidates);
3425 return error_mark_node;
3426 }
3427 cand = tourney (candidates);
3428 if (!cand)
3429 {
3430 op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match");
3431 print_z_candidates (candidates);
3432 return error_mark_node;
3433 }
3434
3435 /* [expr.cond]
3436
3437 Otherwise, the conversions thus determined are applied, and
3438 the converted operands are used in place of the original
3439 operands for the remainder of this section. */
3440 conv = cand->convs[0];
3441 arg1 = convert_like (conv, arg1);
3442 conv = cand->convs[1];
3443 arg2 = convert_like (conv, arg2);
3444 conv = cand->convs[2];
3445 arg3 = convert_like (conv, arg3);
3446 }
3447
3448 /* [expr.cond]
3449
3450 Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_),
3451 and function-to-pointer (_conv.func_) standard conversions are
3452 performed on the second and third operands.
3453
3454 We need to force the lvalue-to-rvalue conversion here for class types,
3455 so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues
3456 that isn't wrapped with a TARGET_EXPR plays havoc with exception
3457 regions. */
3458
3459 arg2 = force_rvalue (arg2);
3460 if (!CLASS_TYPE_P (arg2_type))
3461 arg2_type = TREE_TYPE (arg2);
3462
3463 arg3 = force_rvalue (arg3);
3464 if (!CLASS_TYPE_P (arg2_type))
3465 arg3_type = TREE_TYPE (arg3);
3466
3467 if (arg2 == error_mark_node || arg3 == error_mark_node)
3468 return error_mark_node;
3469
3470 /* [expr.cond]
3471
3472 After those conversions, one of the following shall hold:
3473
3474 --The second and third operands have the same type; the result is of
3475 that type. */
3476 if (same_type_p (arg2_type, arg3_type))
3477 result_type = arg2_type;
3478 /* [expr.cond]
3479
3480 --The second and third operands have arithmetic or enumeration
3481 type; the usual arithmetic conversions are performed to bring
3482 them to a common type, and the result is of that type. */
3483 else if ((ARITHMETIC_TYPE_P (arg2_type)
3484 || TREE_CODE (arg2_type) == ENUMERAL_TYPE)
3485 && (ARITHMETIC_TYPE_P (arg3_type)
3486 || TREE_CODE (arg3_type) == ENUMERAL_TYPE))
3487 {
3488 /* In this case, there is always a common type. */
3489 result_type = type_after_usual_arithmetic_conversions (arg2_type,
3490 arg3_type);
3491
3492 if (TREE_CODE (arg2_type) == ENUMERAL_TYPE
3493 && TREE_CODE (arg3_type) == ENUMERAL_TYPE)
3494 warning (0, "enumeral mismatch in conditional expression: %qT vs %qT",
3495 arg2_type, arg3_type);
3496 else if (extra_warnings
3497 && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE
3498 && !same_type_p (arg3_type, type_promotes_to (arg2_type)))
3499 || (TREE_CODE (arg3_type) == ENUMERAL_TYPE
3500 && !same_type_p (arg2_type, type_promotes_to (arg3_type)))))
3501 warning (0, "enumeral and non-enumeral type in conditional expression");
3502
3503 arg2 = perform_implicit_conversion (result_type, arg2);
3504 arg3 = perform_implicit_conversion (result_type, arg3);
3505 }
3506 /* [expr.cond]
3507
3508 --The second and third operands have pointer type, or one has
3509 pointer type and the other is a null pointer constant; pointer
3510 conversions (_conv.ptr_) and qualification conversions
3511 (_conv.qual_) are performed to bring them to their composite
3512 pointer type (_expr.rel_). The result is of the composite
3513 pointer type.
3514
3515 --The second and third operands have pointer to member type, or
3516 one has pointer to member type and the other is a null pointer
3517 constant; pointer to member conversions (_conv.mem_) and
3518 qualification conversions (_conv.qual_) are performed to bring
3519 them to a common type, whose cv-qualification shall match the
3520 cv-qualification of either the second or the third operand.
3521 The result is of the common type. */
3522 else if ((null_ptr_cst_p (arg2)
3523 && (TYPE_PTR_P (arg3_type) || TYPE_PTR_TO_MEMBER_P (arg3_type)))
3524 || (null_ptr_cst_p (arg3)
3525 && (TYPE_PTR_P (arg2_type) || TYPE_PTR_TO_MEMBER_P (arg2_type)))
3526 || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type))
3527 || (TYPE_PTRMEM_P (arg2_type) && TYPE_PTRMEM_P (arg3_type))
3528 || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type)))
3529 {
3530 result_type = composite_pointer_type (arg2_type, arg3_type, arg2,
3531 arg3, "conditional expression");
3532 if (result_type == error_mark_node)
3533 return error_mark_node;
3534 arg2 = perform_implicit_conversion (result_type, arg2);
3535 arg3 = perform_implicit_conversion (result_type, arg3);
3536 }
3537
3538 if (!result_type)
3539 {
3540 error ("operands to ?: have different types %qT and %qT",
3541 arg2_type, arg3_type);
3542 return error_mark_node;
3543 }
3544
3545 valid_operands:
3546 result = fold_if_not_in_template (build3 (COND_EXPR, result_type, arg1,
3547 arg2, arg3));
3548 /* We can't use result_type below, as fold might have returned a
3549 throw_expr. */
3550
3551 if (!lvalue_p)
3552 {
3553 /* Expand both sides into the same slot, hopefully the target of
3554 the ?: expression. We used to check for TARGET_EXPRs here,
3555 but now we sometimes wrap them in NOP_EXPRs so the test would
3556 fail. */
3557 if (CLASS_TYPE_P (TREE_TYPE (result)))
3558 result = get_target_expr (result);
3559 /* If this expression is an rvalue, but might be mistaken for an
3560 lvalue, we must add a NON_LVALUE_EXPR. */
3561 result = rvalue (result);
3562 }
3563
3564 return result;
3565}
3566
3567/* OPERAND is an operand to an expression. Perform necessary steps
3568 required before using it. If OPERAND is NULL_TREE, NULL_TREE is
3569 returned. */
3570
3571static tree
3572prep_operand (tree operand)
3573{
3574 if (operand)
3575 {
3576 if (CLASS_TYPE_P (TREE_TYPE (operand))
3577 && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand)))
3578 /* Make sure the template type is instantiated now. */
3579 instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand)));
3580 }
3581
3582 return operand;
3583}
3584
3585/* Add each of the viable functions in FNS (a FUNCTION_DECL or
3586 OVERLOAD) to the CANDIDATES, returning an updated list of
3587 CANDIDATES. The ARGS are the arguments provided to the call,
3588 without any implicit object parameter. The EXPLICIT_TARGS are
3589 explicit template arguments provided. TEMPLATE_ONLY is true if
3590 only template functions should be considered. CONVERSION_PATH,
3591 ACCESS_PATH, and FLAGS are as for add_function_candidate. */
3592
3593static void
3594add_candidates (tree fns, tree args,
3595 tree explicit_targs, bool template_only,
3596 tree conversion_path, tree access_path,
3597 int flags,
3598 struct z_candidate **candidates)
3599{
3600 tree ctype;
3601 tree non_static_args;
3602
3603 ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE;
3604 /* Delay creating the implicit this parameter until it is needed. */
3605 non_static_args = NULL_TREE;
3606
3607 while (fns)
3608 {
3609 tree fn;
3610 tree fn_args;
3611
3612 fn = OVL_CURRENT (fns);
3613 /* Figure out which set of arguments to use. */
3614 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
3615 {
3616 /* If this function is a non-static member, prepend the implicit
3617 object parameter. */
3618 if (!non_static_args)
3619 non_static_args = tree_cons (NULL_TREE,
3620 build_this (TREE_VALUE (args)),
3621 TREE_CHAIN (args));
3622 fn_args = non_static_args;
3623 }
3624 else
3625 /* Otherwise, just use the list of arguments provided. */
3626 fn_args = args;
3627
3628 if (TREE_CODE (fn) == TEMPLATE_DECL)
3629 add_template_candidate (candidates,
3630 fn,
3631 ctype,
3632 explicit_targs,
3633 fn_args,
3634 NULL_TREE,
3635 access_path,
3636 conversion_path,
3637 flags,
3638 DEDUCE_CALL);
3639 else if (!template_only)
3640 add_function_candidate (candidates,
3641 fn,
3642 ctype,
3643 fn_args,
3644 access_path,
3645 conversion_path,
3646 flags);
3647 fns = OVL_NEXT (fns);
3648 }
3649}
3650
3651tree
3652build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
3653 bool *overloaded_p)
3654{
3655 struct z_candidate *candidates = 0, *cand;
3656 tree arglist, fnname;
3657 tree args[3];
3658 tree result = NULL_TREE;
3659 bool result_valid_p = false;
3660 enum tree_code code2 = NOP_EXPR;
3661 conversion *conv;
3662 void *p;
3663 bool strict_p;
3664 bool any_viable_p;
3665
3666 if (error_operand_p (arg1)
3667 || error_operand_p (arg2)
3668 || error_operand_p (arg3))
3669 return error_mark_node;
3670
3671 if (code == MODIFY_EXPR)
3672 {
3673 code2 = TREE_CODE (arg3);
3674 arg3 = NULL_TREE;
3675 fnname = ansi_assopname (code2);
3676 }
3677 else
3678 fnname = ansi_opname (code);
3679
3680 arg1 = prep_operand (arg1);
3681
3682 switch (code)
3683 {
3684 case NEW_EXPR:
3685 case VEC_NEW_EXPR:
3686 case VEC_DELETE_EXPR:
3687 case DELETE_EXPR:
3688 /* Use build_op_new_call and build_op_delete_call instead. */
3689 gcc_unreachable ();
3690
3691 case CALL_EXPR:
3692 return build_object_call (arg1, arg2);
3693
3694 default:
3695 break;
3696 }
3697
3698 arg2 = prep_operand (arg2);
3699 arg3 = prep_operand (arg3);
3700
3701 if (code == COND_EXPR)
3702 {
3703 if (arg2 == NULL_TREE
3704 || TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
3705 || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
3706 || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
3707 && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
3708 goto builtin;
3709 }
3710 else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
3711 && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
3712 goto builtin;
3713
3714 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
3715 arg2 = integer_zero_node;
3716
3717 arglist = NULL_TREE;
3718 if (arg3)
3719 arglist = tree_cons (NULL_TREE, arg3, arglist);
3720 if (arg2)
3721 arglist = tree_cons (NULL_TREE, arg2, arglist);
3722 arglist = tree_cons (NULL_TREE, arg1, arglist);
3723
3724 /* Get the high-water mark for the CONVERSION_OBSTACK. */
3725 p = conversion_obstack_alloc (0);
3726
3727 /* Add namespace-scope operators to the list of functions to
3728 consider. */
3729 add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true),
3730 arglist, NULL_TREE, false, NULL_TREE, NULL_TREE,
3731 flags, &candidates);
3732 /* Add class-member operators to the candidate set. */
3733 if (CLASS_TYPE_P (TREE_TYPE (arg1)))
3734 {
3735 tree fns;
3736
3737 fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1);
3738 if (fns == error_mark_node)
3739 {
3740 result = error_mark_node;
3741 goto user_defined_result_ready;
3742 }
3743 if (fns)
3744 add_candidates (BASELINK_FUNCTIONS (fns), arglist,
3745 NULL_TREE, false,
3746 BASELINK_BINFO (fns),
3747 TYPE_BINFO (TREE_TYPE (arg1)),
3748 flags, &candidates);
3749 }
3750
3751 /* Rearrange the arguments for ?: so that add_builtin_candidate only has
3752 to know about two args; a builtin candidate will always have a first
3753 parameter of type bool. We'll handle that in
3754 build_builtin_candidate. */
3755 if (code == COND_EXPR)
3756 {
3757 args[0] = arg2;
3758 args[1] = arg3;
3759 args[2] = arg1;
3760 }
3761 else
3762 {
3763 args[0] = arg1;
3764 args[1] = arg2;
3765 args[2] = NULL_TREE;
3766 }
3767
3768 add_builtin_candidates (&candidates, code, code2, fnname, args, flags);
3769
3770 switch (code)
3771 {
3772 case COMPOUND_EXPR:
3773 case ADDR_EXPR:
3774 /* For these, the built-in candidates set is empty
3775 [over.match.oper]/3. We don't want non-strict matches
3776 because exact matches are always possible with built-in
3777 operators. The built-in candidate set for COMPONENT_REF
3778 would be empty too, but since there are no such built-in
3779 operators, we accept non-strict matches for them. */
3780 strict_p = true;
3781 break;
3782
3783 default:
3784 strict_p = pedantic;
3785 break;
3786 }
3787
3788 candidates = splice_viable (candidates, strict_p, &any_viable_p);
3789 if (!any_viable_p)
3790 {
3791 switch (code)
3792 {
3793 case POSTINCREMENT_EXPR:
3794 case POSTDECREMENT_EXPR:
3795 /* Look for an `operator++ (int)'. If they didn't have
3796 one, then we fall back to the old way of doing things. */
3797 if (flags & LOOKUP_COMPLAIN)
3798 pedwarn ("no %<%D(int)%> declared for postfix %qs, "
3799 "trying prefix operator instead",
3800 fnname,
3801 operator_name_info[code].name);
3802 if (code == POSTINCREMENT_EXPR)
3803 code = PREINCREMENT_EXPR;
3804 else
3805 code = PREDECREMENT_EXPR;
3806 result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE,
3807 overloaded_p);
3808 break;
3809
3810 /* The caller will deal with these. */
3811 case ADDR_EXPR:
3812 case COMPOUND_EXPR:
3813 case COMPONENT_REF:
3814 result = NULL_TREE;
3815 result_valid_p = true;
3816 break;
3817
3818 default:
3819 if (flags & LOOKUP_COMPLAIN)
3820 {
3821 op_error (code, code2, arg1, arg2, arg3, "no match");
3822 print_z_candidates (candidates);
3823 }
3824 result = error_mark_node;
3825 break;
3826 }
3827 }
3828 else
3829 {
3830 cand = tourney (candidates);
3831 if (cand == 0)
3832 {
3833 if (flags & LOOKUP_COMPLAIN)
3834 {
3835 op_error (code, code2, arg1, arg2, arg3, "ambiguous overload");
3836 print_z_candidates (candidates);
3837 }
3838 result = error_mark_node;
3839 }
3840 else if (TREE_CODE (cand->fn) == FUNCTION_DECL)
3841 {
3842 if (overloaded_p)
3843 *overloaded_p = true;
3844
3845 result = build_over_call (cand, LOOKUP_NORMAL);
3846 }
3847 else
3848 {
3849 /* Give any warnings we noticed during overload resolution. */
3850 if (cand->warnings)
3851 {
3852 struct candidate_warning *w;
3853 for (w = cand->warnings; w; w = w->next)
3854 joust (cand, w->loser, 1);
3855 }
3856
3857 /* Check for comparison of different enum types. */
3858 switch (code)
3859 {
3860 case GT_EXPR:
3861 case LT_EXPR:
3862 case GE_EXPR:
3863 case LE_EXPR:
3864 case EQ_EXPR:
3865 case NE_EXPR:
3866 if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE
3867 && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE
3868 && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1))
3869 != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))))
3870 {
3871 warning (0, "comparison between %q#T and %q#T",
3872 TREE_TYPE (arg1), TREE_TYPE (arg2));
3873 }
3874 break;
3875 default:
3876 break;
3877 }
3878
3879 /* We need to strip any leading REF_BIND so that bitfields
3880 don't cause errors. This should not remove any important
3881 conversions, because builtins don't apply to class
3882 objects directly. */
3883 conv = cand->convs[0];
3884 if (conv->kind == ck_ref_bind)
3885 conv = conv->u.next;
3886 arg1 = convert_like (conv, arg1);
3887 if (arg2)
3888 {
3889 conv = cand->convs[1];
3890 if (conv->kind == ck_ref_bind)
3891 conv = conv->u.next;
3892 arg2 = convert_like (conv, arg2);
3893 }
3894 if (arg3)
3895 {
3896 conv = cand->convs[2];
3897 if (conv->kind == ck_ref_bind)
3898 conv = conv->u.next;
3899 arg3 = convert_like (conv, arg3);
3900 }
3901 }
3902 }
3903
3904 user_defined_result_ready:
3905
3906 /* Free all the conversions we allocated. */
3907 obstack_free (&conversion_obstack, p);
3908
3909 if (result || result_valid_p)
3910 return result;
3911
3912 builtin:
3913 switch (code)
3914 {
3915 case MODIFY_EXPR:
3916 return build_modify_expr (arg1, code2, arg2);
3917
3918 case INDIRECT_REF:
3919 return build_indirect_ref (arg1, "unary *");
3920
3921 case PLUS_EXPR:
3922 case MINUS_EXPR:
3923 case MULT_EXPR:
3924 case TRUNC_DIV_EXPR:
3925 case GT_EXPR:
3926 case LT_EXPR:
3927 case GE_EXPR:
3928 case LE_EXPR:
3929 case EQ_EXPR:
3930 case NE_EXPR:
3931 case MAX_EXPR:
3932 case MIN_EXPR:
3933 case LSHIFT_EXPR:
3934 case RSHIFT_EXPR:
3935 case TRUNC_MOD_EXPR:
3936 case BIT_AND_EXPR:
3937 case BIT_IOR_EXPR:
3938 case BIT_XOR_EXPR:
3939 case TRUTH_ANDIF_EXPR:
3940 case TRUTH_ORIF_EXPR:
3941 return cp_build_binary_op (code, arg1, arg2);
3942
3943 case UNARY_PLUS_EXPR:
3944 case NEGATE_EXPR:
3945 case BIT_NOT_EXPR:
3946 case TRUTH_NOT_EXPR:
3947 case PREINCREMENT_EXPR:
3948 case POSTINCREMENT_EXPR:
3949 case PREDECREMENT_EXPR:
3950 case POSTDECREMENT_EXPR:
3951 case REALPART_EXPR:
3952 case IMAGPART_EXPR:
3953 return build_unary_op (code, arg1, candidates != 0);
3954
3955 case ARRAY_REF:
3956 return build_array_ref (arg1, arg2);
3957
3958 case COND_EXPR:
3959 return build_conditional_expr (arg1, arg2, arg3);
3960
3961 case MEMBER_REF:
3962 return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2);
3963
3964 /* The caller will deal with these. */
3965 case ADDR_EXPR:
3966 case COMPONENT_REF:
3967 case COMPOUND_EXPR:
3968 return NULL_TREE;
3969
3970 default:
3971 gcc_unreachable ();
3972 }
3973 return NULL_TREE;
3974}
3975
3976/* Build a call to operator delete. This has to be handled very specially,
3977 because the restrictions on what signatures match are different from all
3978 other call instances. For a normal delete, only a delete taking (void *)
3979 or (void *, size_t) is accepted. For a placement delete, only an exact
3980 match with the placement new is accepted.
3981
3982 CODE is either DELETE_EXPR or VEC_DELETE_EXPR.
3983 ADDR is the pointer to be deleted.
3984 SIZE is the size of the memory block to be deleted.
3985 GLOBAL_P is true if the delete-expression should not consider
3986 class-specific delete operators.
3987 PLACEMENT is the corresponding placement new call, or NULL_TREE.
3988
3989 If this call to "operator delete" is being generated as part to
3990 deallocate memory allocated via a new-expression (as per [expr.new]
3991 which requires that if the initialization throws an exception then
3992 we call a deallocation function), then ALLOC_FN is the allocation
3993 function. */
3994
3995tree
3996build_op_delete_call (enum tree_code code, tree addr, tree size,
3997 bool global_p, tree placement,
3998 tree alloc_fn)
3999{
4000 tree fn = NULL_TREE;
4001 tree fns, fnname, argtypes, args, type;
4002 int pass;
4003
4004 if (addr == error_mark_node)
4005 return error_mark_node;
4006
4007 type = strip_array_types (TREE_TYPE (TREE_TYPE (addr)));
4008
4009 fnname = ansi_opname (code);
4010
4011 if (CLASS_TYPE_P (type)
4012 && COMPLETE_TYPE_P (complete_type (type))
4013 && !global_p)
4014 /* In [class.free]
4015
4016 If the result of the lookup is ambiguous or inaccessible, or if
4017 the lookup selects a placement deallocation function, the
4018 program is ill-formed.
4019
4020 Therefore, we ask lookup_fnfields to complain about ambiguity. */
4021 {
4022 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1);
4023 if (fns == error_mark_node)
4024 return error_mark_node;
4025 }
4026 else
4027 fns = NULL_TREE;
4028
4029 if (fns == NULL_TREE)
4030 fns = lookup_name_nonclass (fnname);
4031
4032 if (placement)
4033 {
4034 /* Get the parameter types for the allocation function that is
4035 being called. */
4036 gcc_assert (alloc_fn != NULL_TREE);
4037 argtypes = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn)));
4038 /* Also the second argument. */
4039 args = TREE_CHAIN (TREE_OPERAND (placement, 1));
4040 }
4041 else
4042 {
4043 /* First try it without the size argument. */
4044 argtypes = void_list_node;
4045 args = NULL_TREE;
4046 }
4047
4048 /* Strip const and volatile from addr. */
4049 addr = cp_convert (ptr_type_node, addr);
4050
4051 /* We make two tries at finding a matching `operator delete'. On
4052 the first pass, we look for a one-operator (or placement)
4053 operator delete. If we're not doing placement delete, then on
4054 the second pass we look for a two-argument delete. */
4055 for (pass = 0; pass < (placement ? 1 : 2); ++pass)
4056 {
4057 /* Go through the `operator delete' functions looking for one
4058 with a matching type. */
4059 for (fn = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns;
4060 fn;
4061 fn = OVL_NEXT (fn))
4062 {
4063 tree t;
4064
4065 /* The first argument must be "void *". */
4066 t = TYPE_ARG_TYPES (TREE_TYPE (OVL_CURRENT (fn)));
4067 if (!same_type_p (TREE_VALUE (t), ptr_type_node))
4068 continue;
4069 t = TREE_CHAIN (t);
4070 /* On the first pass, check the rest of the arguments. */
4071 if (pass == 0)
4072 {
4073 tree a = argtypes;
4074 while (a && t)
4075 {
4076 if (!same_type_p (TREE_VALUE (a), TREE_VALUE (t)))
4077 break;
4078 a = TREE_CHAIN (a);
4079 t = TREE_CHAIN (t);
4080 }
4081 if (!a && !t)
4082 break;
4083 }
4084 /* On the second pass, look for a function with exactly two
4085 arguments: "void *" and "size_t". */
4086 else if (pass == 1
4087 /* For "operator delete(void *, ...)" there will be
4088 no second argument, but we will not get an exact
4089 match above. */
4090 && t
4091 && same_type_p (TREE_VALUE (t), sizetype)
4092 && TREE_CHAIN (t) == void_list_node)
4093 break;
4094 }
4095
4096 /* If we found a match, we're done. */
4097 if (fn)
4098 break;
4099 }
4100
4101 /* If we have a matching function, call it. */
4102 if (fn)
4103 {
4104 /* Make sure we have the actual function, and not an
4105 OVERLOAD. */
4106 fn = OVL_CURRENT (fn);
4107
4108 /* If the FN is a member function, make sure that it is
4109 accessible. */
4110 if (DECL_CLASS_SCOPE_P (fn))
4111 perform_or_defer_access_check (TYPE_BINFO (type), fn, fn);
4112
4113 if (pass == 0)
4114 args = tree_cons (NULL_TREE, addr, args);
4115 else
4116 args = tree_cons (NULL_TREE, addr,
4117 build_tree_list (NULL_TREE, size));
4118
4119 if (placement)
4120 {
4121 /* The placement args might not be suitable for overload
4122 resolution at this point, so build the call directly. */
4123 mark_used (fn);
4124 return build_cxx_call (fn, args);
4125 }
4126 else
4127 return build_function_call (fn, args);
4128 }
4129
4130 /* [expr.new]
4131
4132 If no unambiguous matching deallocation function can be found,
4133 propagating the exception does not cause the object's memory to
4134 be freed. */
4135 if (alloc_fn)
4136 {
4137 if (!placement)
4138 warning (0, "no corresponding deallocation function for `%D'",
4139 alloc_fn);
4140 return NULL_TREE;
4141 }
4142
4143 error ("no suitable %<operator %s%> for %qT",
4144 operator_name_info[(int)code].name, type);
4145 return error_mark_node;
4146}
4147
4148/* If the current scope isn't allowed to access DECL along
4149 BASETYPE_PATH, give an error. The most derived class in
4150 BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is
4151 the declaration to use in the error diagnostic. */
4152
4153bool
4154enforce_access (tree basetype_path, tree decl, tree diag_decl)
4155{
4156 gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO);
4157
4158 if (!accessible_p (basetype_path, decl, true))
4159 {
4160 if (TREE_PRIVATE (decl))
4161 error ("%q+#D is private", diag_decl);
4162 else if (TREE_PROTECTED (decl))
4163 error ("%q+#D is protected", diag_decl);
4164 else
4165 error ("%q+#D is inaccessible", diag_decl);
4166 error ("within this context");
4167 return false;
4168 }
4169
4170 return true;
4171}
4172
4173/* Check that a callable constructor to initialize a temporary of
4174 TYPE from an EXPR exists. */
4175
4176static void
4177check_constructor_callable (tree type, tree expr)
4178{
4179 build_special_member_call (NULL_TREE,
4180 complete_ctor_identifier,
4181 build_tree_list (NULL_TREE, expr),
4182 type,
4183 LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING
4184 | LOOKUP_NO_CONVERSION
4185 | LOOKUP_CONSTRUCTOR_CALLABLE);
4186}
4187
4188/* Initialize a temporary of type TYPE with EXPR. The FLAGS are a
4189 bitwise or of LOOKUP_* values. If any errors are warnings are
4190 generated, set *DIAGNOSTIC_FN to "error" or "warning",
4191 respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN
4192 to NULL. */
4193
4194static tree
4195build_temp (tree expr, tree type, int flags,
4196 diagnostic_fn_t *diagnostic_fn)
4197{
4198 int savew, savee;
4199
4200 savew = warningcount, savee = errorcount;
4201 expr = build_special_member_call (NULL_TREE,
4202 complete_ctor_identifier,
4203 build_tree_list (NULL_TREE, expr),
4204 type, flags);
4205 if (warningcount > savew)
4206 *diagnostic_fn = warning0;
4207 else if (errorcount > savee)
4208 *diagnostic_fn = error;
4209 else
4210 *diagnostic_fn = NULL;
4211 return expr;
4212}
4213
4214
4215/* Perform the conversions in CONVS on the expression EXPR. FN and
4216 ARGNUM are used for diagnostics. ARGNUM is zero based, -1
4217 indicates the `this' argument of a method. INNER is nonzero when
4218 being called to continue a conversion chain. It is negative when a
4219 reference binding will be applied, positive otherwise. If
4220 ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious
4221 conversions will be emitted if appropriate. If C_CAST_P is true,
4222 this conversion is coming from a C-style cast; in that case,
4223 conversions to inaccessible bases are permitted. */
4224
4225static tree
4226convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
4227 int inner, bool issue_conversion_warnings,
4228 bool c_cast_p)
4229{
4230 tree totype = convs->type;
4231 diagnostic_fn_t diagnostic_fn;
4232
4233 if (convs->bad_p
4234 && convs->kind != ck_user
4235 && convs->kind != ck_ambig
4236 && convs->kind != ck_ref_bind)
4237 {
4238 conversion *t = convs;
4239 for (; t; t = convs->u.next)
4240 {
4241 if (t->kind == ck_user || !t->bad_p)
4242 {
4243 expr = convert_like_real (t, expr, fn, argnum, 1,
4244 /*issue_conversion_warnings=*/false,
4245 /*c_cast_p=*/false);
4246 break;
4247 }
4248 else if (t->kind == ck_ambig)
4249 return convert_like_real (t, expr, fn, argnum, 1,
4250 /*issue_conversion_warnings=*/false,
4251 /*c_cast_p=*/false);
4252 else if (t->kind == ck_identity)
4253 break;
4254 }
4255 pedwarn ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype);
4256 if (fn)
4257 pedwarn (" initializing argument %P of %qD", argnum, fn);
4258 return cp_convert (totype, expr);
4259 }
4260
4261 if (issue_conversion_warnings)
4262 {
4263 tree t = non_reference (totype);
4264
4265 /* Issue warnings about peculiar, but valid, uses of NULL. */
4266 if (ARITHMETIC_TYPE_P (t) && expr == null_node)
4267 {
4268 if (fn)
4269 warning (OPT_Wconversion, "passing NULL to non-pointer argument %P of %qD",
4270 argnum, fn);
4271 else
4272 warning (OPT_Wconversion, "converting to non-pointer type %qT from NULL", t);
4273 }
4274
4275 /* Warn about assigning a floating-point type to an integer type. */
4276 if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
4277 && TREE_CODE (t) == INTEGER_TYPE)
4278 {
4279 if (fn)
4280 warning (OPT_Wconversion, "passing %qT for argument %P to %qD",
4281 TREE_TYPE (expr), argnum, fn);
4282 else
4283 warning (OPT_Wconversion, "converting to %qT from %qT", t, TREE_TYPE (expr));
4284 }
4285 }
4286
4287 switch (convs->kind)
4288 {
4289 case ck_user:
4290 {
4291 struct z_candidate *cand = convs->cand;
4292 tree convfn = cand->fn;
4293 tree args;
4294
4295 if (DECL_CONSTRUCTOR_P (convfn))
4296 {
4297 tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
4298 0);
4299
4300 args = build_tree_list (NULL_TREE, expr);
4301 /* We should never try to call the abstract or base constructor
4302 from here. */
4303 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (convfn)
4304 && !DECL_HAS_VTT_PARM_P (convfn));
4305 args = tree_cons (NULL_TREE, t, args);
4306 }
4307 else
4308 args = build_this (expr);
4309 expr = build_over_call (cand, LOOKUP_NORMAL);
4310
4311 /* If this is a constructor or a function returning an aggr type,
4312 we need to build up a TARGET_EXPR. */
4313 if (DECL_CONSTRUCTOR_P (convfn))
4314 expr = build_cplus_new (totype, expr);
4315
4316 /* The result of the call is then used to direct-initialize the object
4317 that is the destination of the copy-initialization. [dcl.init]
4318
4319 Note that this step is not reflected in the conversion sequence;
4320 it affects the semantics when we actually perform the
4321 conversion, but is not considered during overload resolution.
4322
4323 If the target is a class, that means call a ctor. */
4324 if (IS_AGGR_TYPE (totype)
4325 && (inner >= 0 || !lvalue_p (expr)))
4326 {
4327 expr = (build_temp
4328 (expr, totype,
4329 /* Core issue 84, now a DR, says that we don't
4330 allow UDCs for these args (which deliberately
4331 breaks copy-init of an auto_ptr<Base> from an
4332 auto_ptr<Derived>). */
4333 LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION,
4334 &diagnostic_fn));
4335
4336 if (diagnostic_fn)
4337 {
4338 if (fn)
4339 diagnostic_fn
4340 (" initializing argument %P of %qD from result of %qD",
4341 argnum, fn, convfn);
4342 else
4343 diagnostic_fn
4344 (" initializing temporary from result of %qD", convfn);
4345 }
4346 expr = build_cplus_new (totype, expr);
4347 }
4348 return expr;
4349 }
4350 case ck_identity:
4351 if (type_unknown_p (expr))
4352 expr = instantiate_type (totype, expr, tf_warning_or_error);
4353 /* Convert a constant to its underlying value, unless we are
4354 about to bind it to a reference, in which case we need to
4355 leave it as an lvalue. */
4356 if (inner >= 0)
4357 expr = decl_constant_value (expr);
4358 if (convs->check_copy_constructor_p)
4359 check_constructor_callable (totype, expr);
4360 return expr;
4361 case ck_ambig:
4362 /* Call build_user_type_conversion again for the error. */
4363 return build_user_type_conversion
4364 (totype, convs->u.expr, LOOKUP_NORMAL);
4365
4366 default:
4367 break;
4368 };
4369
4370 expr = convert_like_real (convs->u.next, expr, fn, argnum,
4371 convs->kind == ck_ref_bind ? -1 : 1,
4372 /*issue_conversion_warnings=*/false,
4373 c_cast_p);
4374 if (expr == error_mark_node)
4375 return error_mark_node;
4376
4377 switch (convs->kind)
4378 {
4379 case ck_rvalue:
4380 expr = convert_bitfield_to_declared_type (expr);
4381 if (! IS_AGGR_TYPE (totype))
4382 return expr;
4383 /* Else fall through. */
4384 case ck_base:
4385 if (convs->kind == ck_base && !convs->need_temporary_p)
4386 {
4387 /* We are going to bind a reference directly to a base-class
4388 subobject of EXPR. */
4389 if (convs->check_copy_constructor_p)
4390 check_constructor_callable (TREE_TYPE (expr), expr);
4391 /* Build an expression for `*((base*) &expr)'. */
4392 expr = build_unary_op (ADDR_EXPR, expr, 0);
4393 expr = convert_to_base (expr, build_pointer_type (totype),
4394 !c_cast_p, /*nonnull=*/true);
4395 expr = build_indirect_ref (expr, "implicit conversion");
4396 return expr;
4397 }
4398
4399 /* Copy-initialization where the cv-unqualified version of the source
4400 type is the same class as, or a derived class of, the class of the
4401 destination [is treated as direct-initialization]. [dcl.init] */
4402 expr = build_temp (expr, totype, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
4403 &diagnostic_fn);
4404 if (diagnostic_fn && fn)
4405 diagnostic_fn (" initializing argument %P of %qD", argnum, fn);
4406 return build_cplus_new (totype, expr);
4407
4408 case ck_ref_bind:
4409 {
4410 tree ref_type = totype;
4411
4412 /* If necessary, create a temporary. */
4413 if (convs->need_temporary_p || !lvalue_p (expr))
4414 {
4415 tree type = convs->u.next->type;
4416 cp_lvalue_kind lvalue = real_lvalue_p (expr);
4417
4418 if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
4419 {
4420 /* If the reference is volatile or non-const, we
4421 cannot create a temporary. */
4422 if (lvalue & clk_bitfield)
4423 error ("cannot bind bitfield %qE to %qT",
4424 expr, ref_type);
4425 else if (lvalue & clk_packed)
4426 error ("cannot bind packed field %qE to %qT",
4427 expr, ref_type);
4428 else
4429 error ("cannot bind rvalue %qE to %qT", expr, ref_type);
4430 return error_mark_node;
4431 }
4432 /* If the source is a packed field, and we must use a copy
4433 constructor, then building the target expr will require
4434 binding the field to the reference parameter to the
4435 copy constructor, and we'll end up with an infinite
4436 loop. If we can use a bitwise copy, then we'll be
4437 OK. */
4438 if ((lvalue & clk_packed)
4439 && CLASS_TYPE_P (type)
4440 && !TYPE_HAS_TRIVIAL_INIT_REF (type))
4441 {
4442 error ("cannot bind packed field %qE to %qT",
4443 expr, ref_type);
4444 return error_mark_node;
4445 }
4446 expr = build_target_expr_with_type (expr, type);
4447 }
4448
4449 /* Take the address of the thing to which we will bind the
4450 reference. */
4451 expr = build_unary_op (ADDR_EXPR, expr, 1);
4452 if (expr == error_mark_node)
4453 return error_mark_node;
4454
4455 /* Convert it to a pointer to the type referred to by the
4456 reference. This will adjust the pointer if a derived to
4457 base conversion is being performed. */
4458 expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)),
4459 expr);
4460 /* Convert the pointer to the desired reference type. */
4461 return build_nop (ref_type, expr);
4462 }
4463
4464 case ck_lvalue:
4465 return decay_conversion (expr);
4466
4467 case ck_qual:
4468 /* Warn about deprecated conversion if appropriate. */
4469 string_conv_p (totype, expr, 1);
4470 break;
4471
4472 case ck_ptr:
4473 if (convs->base_p)
4474 expr = convert_to_base (expr, totype, !c_cast_p,
4475 /*nonnull=*/false);
4476 return build_nop (totype, expr);
4477
4478 case ck_pmem:
4479 return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false,
4480 c_cast_p);
4481
4482 default:
4483 break;
4484 }
4485
4486 if (issue_conversion_warnings)
4487 expr = convert_and_check (totype, expr);
4488 else
4489 expr = convert (totype, expr);
4490
4491 return expr;
4492}
4493
4494/* Build a call to __builtin_trap. */
4495
4496static tree
4497call_builtin_trap (void)
4498{
4499 tree fn = implicit_built_in_decls[BUILT_IN_TRAP];
4500
4501 gcc_assert (fn != NULL);
4502 fn = build_call (fn, NULL_TREE);
4503 return fn;
4504}
4505
4506/* ARG is being passed to a varargs function. Perform any conversions
4507 required. Return the converted value. */
4508
4509tree
4510convert_arg_to_ellipsis (tree arg)
4511{
4512 /* [expr.call]
4513
4514 The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4515 standard conversions are performed. */
4516 arg = decay_conversion (arg);
4517 /* [expr.call]
4518
4519 If the argument has integral or enumeration type that is subject
4520 to the integral promotions (_conv.prom_), or a floating point
4521 type that is subject to the floating point promotion
4522 (_conv.fpprom_), the value of the argument is converted to the
4523 promoted type before the call. */
4524 if (TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
4525 && (TYPE_PRECISION (TREE_TYPE (arg))
4526 < TYPE_PRECISION (double_type_node)))
4527 arg = convert_to_real (double_type_node, arg);
4528 else if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (arg)))
4529 arg = perform_integral_promotions (arg);
4530
4531 arg = require_complete_type (arg);
4532
4533 if (arg != error_mark_node
4534 && !pod_type_p (TREE_TYPE (arg)))
4535 {
4536 /* Undefined behavior [expr.call] 5.2.2/7. We used to just warn
4537 here and do a bitwise copy, but now cp_expr_size will abort if we
4538 try to do that.
4539 If the call appears in the context of a sizeof expression,
4540 there is no need to emit a warning, since the expression won't be
4541 evaluated. We keep the builtin_trap just as a safety check. */
4542 if (!skip_evaluation)
4543 warning (0, "cannot pass objects of non-POD type %q#T through %<...%>; "
4544 "call will abort at runtime", TREE_TYPE (arg));
4545 arg = call_builtin_trap ();
4546 arg = build2 (COMPOUND_EXPR, integer_type_node, arg,
4547 integer_zero_node);
4548 }
4549
4550 return arg;
4551}
4552
4553/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */
4554
4555tree
4556build_x_va_arg (tree expr, tree type)
4557{
4558 if (processing_template_decl)
4559 return build_min (VA_ARG_EXPR, type, expr);
4560
4561 type = complete_type_or_else (type, NULL_TREE);
4562
4563 if (expr == error_mark_node || !type)
4564 return error_mark_node;
4565
4566 if (! pod_type_p (type))
4567 {
4568 /* Remove reference types so we don't ICE later on. */
4569 tree type1 = non_reference (type);
4570 /* Undefined behavior [expr.call] 5.2.2/7. */
4571 warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
4572 "call will abort at runtime", type);
4573 expr = convert (build_pointer_type (type1), null_node);
4574 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
4575 call_builtin_trap (), expr);
4576 expr = build_indirect_ref (expr, NULL);
4577 return expr;
4578 }
4579
4580 return build_va_arg (expr, type);
4581}
4582
4583/* TYPE has been given to va_arg. Apply the default conversions which
4584 would have happened when passed via ellipsis. Return the promoted
4585 type, or the passed type if there is no change. */
4586
4587tree
4588cxx_type_promotes_to (tree type)
4589{
4590 tree promote;
4591
4592 /* Perform the array-to-pointer and function-to-pointer
4593 conversions. */
4594 type = type_decays_to (type);
4595
4596 promote = type_promotes_to (type);
4597 if (same_type_p (type, promote))
4598 promote = type;
4599
4600 return promote;
4601}
4602
4603/* ARG is a default argument expression being passed to a parameter of
4604 the indicated TYPE, which is a parameter to FN. Do any required
4605 conversions. Return the converted value. */
4606
4607tree
4608convert_default_arg (tree type, tree arg, tree fn, int parmnum)
4609{
4610 /* If the ARG is an unparsed default argument expression, the
4611 conversion cannot be performed. */
4612 if (TREE_CODE (arg) == DEFAULT_ARG)
4613 {
4614 error ("the default argument for parameter %d of %qD has "
4615 "not yet been parsed",
4616 parmnum, fn);
4617 return error_mark_node;
4618 }
4619
4620 if (fn && DECL_TEMPLATE_INFO (fn))
4621 arg = tsubst_default_argument (fn, type, arg);
4622
4623 arg = break_out_target_exprs (arg);
4624
4625 if (TREE_CODE (arg) == CONSTRUCTOR)
4626 {
4627 arg = digest_init (type, arg);
4628 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4629 "default argument", fn, parmnum);
4630 }
4631 else
4632 {
4633 /* We must make a copy of ARG, in case subsequent processing
4634 alters any part of it. For example, during gimplification a
4635 cast of the form (T) &X::f (where "f" is a member function)
4636 will lead to replacing the PTRMEM_CST for &X::f with a
4637 VAR_DECL. We can avoid the copy for constants, since they
4638 are never modified in place. */
4639 if (!CONSTANT_CLASS_P (arg))
4640 arg = unshare_expr (arg);
4641 arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL,
4642 "default argument", fn, parmnum);
4643 arg = convert_for_arg_passing (type, arg);
4644 }
4645
4646 return arg;
4647}
4648
4649/* Returns the type which will really be used for passing an argument of
4650 type TYPE. */
4651
4652tree
4653type_passed_as (tree type)
4654{
4655 /* Pass classes with copy ctors by invisible reference. */
4656 if (TREE_ADDRESSABLE (type))
4657 {
4658 type = build_reference_type (type);
4659 /* There are no other pointers to this temporary. */
4660 type = build_qualified_type (type, TYPE_QUAL_RESTRICT);
4661 }
4662 else if (targetm.calls.promote_prototypes (type)
4663 && INTEGRAL_TYPE_P (type)
4664 && COMPLETE_TYPE_P (type)
4665 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4666 TYPE_SIZE (integer_type_node)))
4667 type = integer_type_node;
4668
4669 return type;
4670}
4671
4672/* Actually perform the appropriate conversion. */
4673
4674tree
4675convert_for_arg_passing (tree type, tree val)
4676{
|
4678 if (val == error_mark_node)
4679 ;
4680 /* Pass classes with copy ctors by invisible reference. */
4681 else if (TREE_ADDRESSABLE (type))
4682 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4683 else if (targetm.calls.promote_prototypes (type)
4684 && INTEGRAL_TYPE_P (type)
4685 && COMPLETE_TYPE_P (type)
4686 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4687 TYPE_SIZE (integer_type_node)))
4688 val = perform_integral_promotions (val);
4689 if (warn_missing_format_attribute)
4690 {
4691 tree rhstype = TREE_TYPE (val);
4692 const enum tree_code coder = TREE_CODE (rhstype);
4693 const enum tree_code codel = TREE_CODE (type);
4694 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4695 && coder == codel
4696 && check_missing_format_attribute (type, rhstype))
4697 warning (OPT_Wmissing_format_attribute,
4698 "argument of function call might be a candidate for a format attribute");
4699 }
4700 return val;
4701}
4702
4703/* Returns true iff FN is a function with magic varargs, i.e. ones for
4704 which no conversions at all should be done. This is true for some
4705 builtins which don't act like normal functions. */
4706
4707static bool
4708magic_varargs_p (tree fn)
4709{
4710 if (DECL_BUILT_IN (fn))
4711 switch (DECL_FUNCTION_CODE (fn))
4712 {
4713 case BUILT_IN_CLASSIFY_TYPE:
4714 case BUILT_IN_CONSTANT_P:
4715 case BUILT_IN_NEXT_ARG:
4716 case BUILT_IN_STDARG_START:
4717 case BUILT_IN_VA_START:
4718 return true;
4719
4720 default:;
4721 }
4722
4723 return false;
4724}
4725
4726/* Subroutine of the various build_*_call functions. Overload resolution
4727 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4728 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4729 bitmask of various LOOKUP_* flags which apply to the call itself. */
4730
4731static tree
4732build_over_call (struct z_candidate *cand, int flags)
4733{
4734 tree fn = cand->fn;
4735 tree args = cand->args;
4736 conversion **convs = cand->convs;
4737 conversion *conv;
4738 tree converted_args = NULL_TREE;
4739 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4740 tree arg, val;
4741 int i = 0;
4742 int is_method = 0;
4743
4744 /* In a template, there is no need to perform all of the work that
4745 is normally done. We are only interested in the type of the call
4746 expression, i.e., the return type of the function. Any semantic
4747 errors will be deferred until the template is instantiated. */
4748 if (processing_template_decl)
4749 {
4750 tree expr;
4751 tree return_type;
4752 return_type = TREE_TYPE (TREE_TYPE (fn));
4753 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4754 if (TREE_THIS_VOLATILE (fn) && cfun)
4755 current_function_returns_abnormally = 1;
4756 if (!VOID_TYPE_P (return_type))
4757 require_complete_type (return_type);
4758 return convert_from_reference (expr);
4759 }
4760
4761 /* Give any warnings we noticed during overload resolution. */
4762 if (cand->warnings)
4763 {
4764 struct candidate_warning *w;
4765 for (w = cand->warnings; w; w = w->next)
4766 joust (cand, w->loser, 1);
4767 }
4768
4769 if (DECL_FUNCTION_MEMBER_P (fn))
4770 {
4771 /* If FN is a template function, two cases must be considered.
4772 For example:
4773
4774 struct A {
4775 protected:
4776 template <class T> void f();
4777 };
4778 template <class T> struct B {
4779 protected:
4780 void g();
4781 };
4782 struct C : A, B<int> {
4783 using A::f; // #1
4784 using B<int>::g; // #2
4785 };
4786
4787 In case #1 where `A::f' is a member template, DECL_ACCESS is
4788 recorded in the primary template but not in its specialization.
4789 We check access of FN using its primary template.
4790
4791 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4792 because it is a member of class template B, DECL_ACCESS is
4793 recorded in the specialization `B<int>::g'. We cannot use its
4794 primary template because `B<T>::g' and `B<int>::g' may have
4795 different access. */
4796 if (DECL_TEMPLATE_INFO (fn)
4797 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4798 perform_or_defer_access_check (cand->access_path,
4799 DECL_TI_TEMPLATE (fn), fn);
4800 else
4801 perform_or_defer_access_check (cand->access_path, fn, fn);
4802 }
4803
4804 if (args && TREE_CODE (args) != TREE_LIST)
4805 args = build_tree_list (NULL_TREE, args);
4806 arg = args;
4807
4808 /* The implicit parameters to a constructor are not considered by overload
4809 resolution, and must be of the proper type. */
4810 if (DECL_CONSTRUCTOR_P (fn))
4811 {
4812 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4813 arg = TREE_CHAIN (arg);
4814 parm = TREE_CHAIN (parm);
4815 /* We should never try to call the abstract constructor. */
4816 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4817
4818 if (DECL_HAS_VTT_PARM_P (fn))
4819 {
4820 converted_args = tree_cons
4821 (NULL_TREE, TREE_VALUE (arg), converted_args);
4822 arg = TREE_CHAIN (arg);
4823 parm = TREE_CHAIN (parm);
4824 }
4825 }
4826 /* Bypass access control for 'this' parameter. */
4827 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4828 {
4829 tree parmtype = TREE_VALUE (parm);
4830 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4831 tree converted_arg;
4832 tree base_binfo;
4833
4834 if (convs[i]->bad_p)
4835 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4836 TREE_TYPE (argtype), fn);
4837
4838 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4839 X is called for an object that is not of type X, or of a type
4840 derived from X, the behavior is undefined.
4841
4842 So we can assume that anything passed as 'this' is non-null, and
4843 optimize accordingly. */
4844 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4845 /* Convert to the base in which the function was declared. */
4846 gcc_assert (cand->conversion_path != NULL_TREE);
4847 converted_arg = build_base_path (PLUS_EXPR,
4848 TREE_VALUE (arg),
4849 cand->conversion_path,
4850 1);
4851 /* Check that the base class is accessible. */
4852 if (!accessible_base_p (TREE_TYPE (argtype),
4853 BINFO_TYPE (cand->conversion_path), true))
4854 error ("%qT is not an accessible base of %qT",
4855 BINFO_TYPE (cand->conversion_path),
4856 TREE_TYPE (argtype));
4857 /* If fn was found by a using declaration, the conversion path
4858 will be to the derived class, not the base declaring fn. We
4859 must convert from derived to base. */
4860 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4861 TREE_TYPE (parmtype), ba_unique, NULL);
4862 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4863 base_binfo, 1);
4864
4865 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4866 parm = TREE_CHAIN (parm);
4867 arg = TREE_CHAIN (arg);
4868 ++i;
4869 is_method = 1;
4870 }
4871
4872 for (; arg && parm;
4873 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4874 {
4875 tree type = TREE_VALUE (parm);
4876
4877 conv = convs[i];
4878
4879 /* Don't make a copy here if build_call is going to. */
4880 if (conv->kind == ck_rvalue
4881 && !TREE_ADDRESSABLE (complete_type (type)))
4882 conv = conv->u.next;
4883
4884 val = convert_like_with_context
4885 (conv, TREE_VALUE (arg), fn, i - is_method);
4886
4887 val = convert_for_arg_passing (type, val);
4888 converted_args = tree_cons (NULL_TREE, val, converted_args);
4889 }
4890
4891 /* Default arguments */
4892 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4893 converted_args
4894 = tree_cons (NULL_TREE,
4895 convert_default_arg (TREE_VALUE (parm),
4896 TREE_PURPOSE (parm),
4897 fn, i - is_method),
4898 converted_args);
4899
4900 /* Ellipsis */
4901 for (; arg; arg = TREE_CHAIN (arg))
4902 {
4903 tree a = TREE_VALUE (arg);
4904 if (magic_varargs_p (fn))
4905 /* Do no conversions for magic varargs. */;
4906 else
4907 a = convert_arg_to_ellipsis (a);
4908 converted_args = tree_cons (NULL_TREE, a, converted_args);
4909 }
4910
4911 converted_args = nreverse (converted_args);
4912
4913 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4914 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4915
4916 /* Avoid actually calling copy constructors and copy assignment operators,
4917 if possible. */
4918
4919 if (! flag_elide_constructors)
4920 /* Do things the hard way. */;
4921 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4922 {
4923 tree targ;
4924 arg = skip_artificial_parms_for (fn, converted_args);
4925 arg = TREE_VALUE (arg);
4926
4927 /* Pull out the real argument, disregarding const-correctness. */
4928 targ = arg;
4929 while (TREE_CODE (targ) == NOP_EXPR
4930 || TREE_CODE (targ) == NON_LVALUE_EXPR
4931 || TREE_CODE (targ) == CONVERT_EXPR)
4932 targ = TREE_OPERAND (targ, 0);
4933 if (TREE_CODE (targ) == ADDR_EXPR)
4934 {
4935 targ = TREE_OPERAND (targ, 0);
4936 if (!same_type_ignoring_top_level_qualifiers_p
4937 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4938 targ = NULL_TREE;
4939 }
4940 else
4941 targ = NULL_TREE;
4942
4943 if (targ)
4944 arg = targ;
4945 else
4946 arg = build_indirect_ref (arg, 0);
4947
4948 /* [class.copy]: the copy constructor is implicitly defined even if
4949 the implementation elided its use. */
4950 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4951 mark_used (fn);
4952
4953 /* If we're creating a temp and we already have one, don't create a
4954 new one. If we're not creating a temp but we get one, use
4955 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4956 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4957 temp or an INIT_EXPR otherwise. */
4958 if (integer_zerop (TREE_VALUE (args)))
4959 {
4960 if (TREE_CODE (arg) == TARGET_EXPR)
4961 return arg;
4962 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4963 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4964 }
4965 else if (TREE_CODE (arg) == TARGET_EXPR
4966 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4967 {
4968 tree to = stabilize_reference
4969 (build_indirect_ref (TREE_VALUE (args), 0));
4970
4971 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4972 return val;
4973 }
4974 }
4975 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4976 && copy_fn_p (fn)
4977 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4978 {
4979 tree to = stabilize_reference
4980 (build_indirect_ref (TREE_VALUE (converted_args), 0));
4981 tree type = TREE_TYPE (to);
4982 tree as_base = CLASSTYPE_AS_BASE (type);
4983
4984 arg = TREE_VALUE (TREE_CHAIN (converted_args));
4985 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
4986 {
4987 arg = build_indirect_ref (arg, 0);
4988 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
4989 }
4990 else
4991 {
4992 /* We must only copy the non-tail padding parts.
4993 Use __builtin_memcpy for the bitwise copy. */
4994
4995 tree args, t;
4996
4997 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
4998 args = tree_cons (NULL, arg, args);
4999 t = build_unary_op (ADDR_EXPR, to, 0);
5000 args = tree_cons (NULL, t, args);
5001 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5002 t = build_call (t, args);
5003
5004 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
5005 val = build_indirect_ref (t, 0);
5006 }
5007
5008 return val;
5009 }
5010
5011 mark_used (fn);
5012
5013 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5014 {
5015 tree t, *p = &TREE_VALUE (converted_args);
5016 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
5017 DECL_CONTEXT (fn),
5018 ba_any, NULL);
5019 gcc_assert (binfo && binfo != error_mark_node);
5020
5021 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
5022 if (TREE_SIDE_EFFECTS (*p))
5023 *p = save_expr (*p);
5024 t = build_pointer_type (TREE_TYPE (fn));
5025 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5026 fn = build_java_interface_fn_ref (fn, *p);
5027 else
5028 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
5029 TREE_TYPE (fn) = t;
5030 }
5031 else if (DECL_INLINE (fn))
5032 fn = inline_conversion (fn);
5033 else
5034 fn = build_addr_func (fn);
5035
5036 return build_cxx_call (fn, converted_args);
5037}
5038
5039/* Build and return a call to FN, using ARGS. This function performs
5040 no overload resolution, conversion, or other high-level
5041 operations. */
5042
5043tree
5044build_cxx_call (tree fn, tree args)
5045{
5046 tree fndecl;
5047
5048 fn = build_call (fn, args);
5049
5050 /* If this call might throw an exception, note that fact. */
5051 fndecl = get_callee_fndecl (fn);
5052 if ((!fndecl || !TREE_NOTHROW (fndecl))
5053 && at_function_scope_p ()
5054 && cfun)
5055 cp_function_chain->can_throw = 1;
5056
5057 /* Some built-in function calls will be evaluated at compile-time in
5058 fold (). */
5059 fn = fold_if_not_in_template (fn);
5060
5061 if (VOID_TYPE_P (TREE_TYPE (fn)))
5062 return fn;
5063
5064 fn = require_complete_type (fn);
5065 if (fn == error_mark_node)
5066 return error_mark_node;
5067
5068 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5069 fn = build_cplus_new (TREE_TYPE (fn), fn);
5070 return convert_from_reference (fn);
5071}
5072
5073static GTY(()) tree java_iface_lookup_fn;
5074
5075/* Make an expression which yields the address of the Java interface
5076 method FN. This is achieved by generating a call to libjava's
5077 _Jv_LookupInterfaceMethodIdx(). */
5078
5079static tree
5080build_java_interface_fn_ref (tree fn, tree instance)
5081{
5082 tree lookup_args, lookup_fn, method, idx;
5083 tree klass_ref, iface, iface_ref;
5084 int i;
5085
5086 if (!java_iface_lookup_fn)
5087 {
5088 tree endlink = build_void_list_node ();
5089 tree t = tree_cons (NULL_TREE, ptr_type_node,
5090 tree_cons (NULL_TREE, ptr_type_node,
5091 tree_cons (NULL_TREE, java_int_type_node,
5092 endlink)));
5093 java_iface_lookup_fn
5094 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5095 build_function_type (ptr_type_node, t),
5096 0, NOT_BUILT_IN, NULL, NULL_TREE);
5097 }
5098
5099 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5100 This is the first entry in the vtable. */
5101 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5102 integer_zero_node);
5103
5104 /* Get the java.lang.Class pointer for the interface being called. */
5105 iface = DECL_CONTEXT (fn);
5106 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5107 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5108 || DECL_CONTEXT (iface_ref) != iface)
5109 {
5110 error ("could not find class$ field in java interface type %qT",
5111 iface);
5112 return error_mark_node;
5113 }
5114 iface_ref = build_address (iface_ref);
5115 iface_ref = convert (build_pointer_type (iface), iface_ref);
5116
5117 /* Determine the itable index of FN. */
5118 i = 1;
5119 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5120 {
5121 if (!DECL_VIRTUAL_P (method))
5122 continue;
5123 if (fn == method)
5124 break;
5125 i++;
5126 }
5127 idx = build_int_cst (NULL_TREE, i);
5128
5129 lookup_args = tree_cons (NULL_TREE, klass_ref,
5130 tree_cons (NULL_TREE, iface_ref,
5131 build_tree_list (NULL_TREE, idx)));
5132 lookup_fn = build1 (ADDR_EXPR,
5133 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5134 java_iface_lookup_fn);
5135 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5136}
5137
5138/* Returns the value to use for the in-charge parameter when making a
5139 call to a function with the indicated NAME.
5140
5141 FIXME:Can't we find a neater way to do this mapping? */
5142
5143tree
5144in_charge_arg_for_name (tree name)
5145{
5146 if (name == base_ctor_identifier
5147 || name == base_dtor_identifier)
5148 return integer_zero_node;
5149 else if (name == complete_ctor_identifier)
5150 return integer_one_node;
5151 else if (name == complete_dtor_identifier)
5152 return integer_two_node;
5153 else if (name == deleting_dtor_identifier)
5154 return integer_three_node;
5155
5156 /* This function should only be called with one of the names listed
5157 above. */
5158 gcc_unreachable ();
5159 return NULL_TREE;
5160}
5161
5162/* Build a call to a constructor, destructor, or an assignment
5163 operator for INSTANCE, an expression with class type. NAME
5164 indicates the special member function to call; ARGS are the
5165 arguments. BINFO indicates the base of INSTANCE that is to be
5166 passed as the `this' parameter to the member function called.
5167
5168 FLAGS are the LOOKUP_* flags to use when processing the call.
5169
5170 If NAME indicates a complete object constructor, INSTANCE may be
5171 NULL_TREE. In this case, the caller will call build_cplus_new to
5172 store the newly constructed object into a VAR_DECL. */
5173
5174tree
5175build_special_member_call (tree instance, tree name, tree args,
5176 tree binfo, int flags)
5177{
5178 tree fns;
5179 /* The type of the subobject to be constructed or destroyed. */
5180 tree class_type;
5181
5182 gcc_assert (name == complete_ctor_identifier
5183 || name == base_ctor_identifier
5184 || name == complete_dtor_identifier
5185 || name == base_dtor_identifier
5186 || name == deleting_dtor_identifier
5187 || name == ansi_assopname (NOP_EXPR));
5188 if (TYPE_P (binfo))
5189 {
5190 /* Resolve the name. */
5191 if (!complete_type_or_else (binfo, NULL_TREE))
5192 return error_mark_node;
5193
5194 binfo = TYPE_BINFO (binfo);
5195 }
5196
5197 gcc_assert (binfo != NULL_TREE);
5198
5199 class_type = BINFO_TYPE (binfo);
5200
5201 /* Handle the special case where INSTANCE is NULL_TREE. */
5202 if (name == complete_ctor_identifier && !instance)
5203 {
5204 instance = build_int_cst (build_pointer_type (class_type), 0);
5205 instance = build1 (INDIRECT_REF, class_type, instance);
5206 }
5207 else
5208 {
5209 if (name == complete_dtor_identifier
5210 || name == base_dtor_identifier
5211 || name == deleting_dtor_identifier)
5212 gcc_assert (args == NULL_TREE);
5213
5214 /* Convert to the base class, if necessary. */
5215 if (!same_type_ignoring_top_level_qualifiers_p
5216 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5217 {
5218 if (name != ansi_assopname (NOP_EXPR))
5219 /* For constructors and destructors, either the base is
5220 non-virtual, or it is virtual but we are doing the
5221 conversion from a constructor or destructor for the
5222 complete object. In either case, we can convert
5223 statically. */
5224 instance = convert_to_base_statically (instance, binfo);
5225 else
5226 /* However, for assignment operators, we must convert
5227 dynamically if the base is virtual. */
5228 instance = build_base_path (PLUS_EXPR, instance,
5229 binfo, /*nonnull=*/1);
5230 }
5231 }
5232
5233 gcc_assert (instance != NULL_TREE);
5234
5235 fns = lookup_fnfields (binfo, name, 1);
5236
5237 /* When making a call to a constructor or destructor for a subobject
5238 that uses virtual base classes, pass down a pointer to a VTT for
5239 the subobject. */
5240 if ((name == base_ctor_identifier
5241 || name == base_dtor_identifier)
5242 && CLASSTYPE_VBASECLASSES (class_type))
5243 {
5244 tree vtt;
5245 tree sub_vtt;
5246
5247 /* If the current function is a complete object constructor
5248 or destructor, then we fetch the VTT directly.
5249 Otherwise, we look it up using the VTT we were given. */
5250 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5251 vtt = decay_conversion (vtt);
5252 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5253 build2 (EQ_EXPR, boolean_type_node,
5254 current_in_charge_parm, integer_zero_node),
5255 current_vtt_parm,
5256 vtt);
5257 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5258 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5259 BINFO_SUBVTT_INDEX (binfo));
5260
5261 args = tree_cons (NULL_TREE, sub_vtt, args);
5262 }
5263
5264 return build_new_method_call (instance, fns, args,
5265 TYPE_BINFO (BINFO_TYPE (binfo)),
5266 flags, /*fn=*/NULL);
5267}
5268
5269/* Return the NAME, as a C string. The NAME indicates a function that
5270 is a member of TYPE. *FREE_P is set to true if the caller must
5271 free the memory returned.
5272
5273 Rather than go through all of this, we should simply set the names
5274 of constructors and destructors appropriately, and dispense with
5275 ctor_identifier, dtor_identifier, etc. */
5276
5277static char *
5278name_as_c_string (tree name, tree type, bool *free_p)
5279{
5280 char *pretty_name;
5281
5282 /* Assume that we will not allocate memory. */
5283 *free_p = false;
5284 /* Constructors and destructors are special. */
5285 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5286 {
5287 pretty_name
5288 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5289 /* For a destructor, add the '~'. */
5290 if (name == complete_dtor_identifier
5291 || name == base_dtor_identifier
5292 || name == deleting_dtor_identifier)
5293 {
5294 pretty_name = concat ("~", pretty_name, NULL);
5295 /* Remember that we need to free the memory allocated. */
5296 *free_p = true;
5297 }
5298 }
5299 else if (IDENTIFIER_TYPENAME_P (name))
5300 {
5301 pretty_name = concat ("operator ",
5302 type_as_string (TREE_TYPE (name),
5303 TFF_PLAIN_IDENTIFIER),
5304 NULL);
5305 /* Remember that we need to free the memory allocated. */
5306 *free_p = true;
5307 }
5308 else
5309 pretty_name = (char *) IDENTIFIER_POINTER (name);
5310
5311 return pretty_name;
5312}
5313
5314/* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5315 be set, upon return, to the function called. */
5316
5317tree
5318build_new_method_call (tree instance, tree fns, tree args,
5319 tree conversion_path, int flags,
5320 tree *fn_p)
5321{
5322 struct z_candidate *candidates = 0, *cand;
5323 tree explicit_targs = NULL_TREE;
5324 tree basetype = NULL_TREE;
5325 tree access_binfo;
5326 tree optype;
5327 tree mem_args = NULL_TREE, instance_ptr;
5328 tree name;
5329 tree user_args;
5330 tree call;
5331 tree fn;
5332 tree class_type;
5333 int template_only = 0;
5334 bool any_viable_p;
5335 tree orig_instance;
5336 tree orig_fns;
5337 tree orig_args;
5338 void *p;
5339
5340 gcc_assert (instance != NULL_TREE);
5341
5342 /* We don't know what function we're going to call, yet. */
5343 if (fn_p)
5344 *fn_p = NULL_TREE;
5345
5346 if (error_operand_p (instance)
5347 || error_operand_p (fns)
5348 || args == error_mark_node)
5349 return error_mark_node;
5350
5351 if (!BASELINK_P (fns))
5352 {
5353 error ("call to non-function %qD", fns);
5354 return error_mark_node;
5355 }
5356
5357 orig_instance = instance;
5358 orig_fns = fns;
5359 orig_args = args;
5360
5361 /* Dismantle the baselink to collect all the information we need. */
5362 if (!conversion_path)
5363 conversion_path = BASELINK_BINFO (fns);
5364 access_binfo = BASELINK_ACCESS_BINFO (fns);
5365 optype = BASELINK_OPTYPE (fns);
5366 fns = BASELINK_FUNCTIONS (fns);
5367 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5368 {
5369 explicit_targs = TREE_OPERAND (fns, 1);
5370 fns = TREE_OPERAND (fns, 0);
5371 template_only = 1;
5372 }
5373 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5374 || TREE_CODE (fns) == TEMPLATE_DECL
5375 || TREE_CODE (fns) == OVERLOAD);
5376 fn = get_first_fn (fns);
5377 name = DECL_NAME (fn);
5378
5379 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5380 gcc_assert (CLASS_TYPE_P (basetype));
5381
5382 if (processing_template_decl)
5383 {
5384 instance = build_non_dependent_expr (instance);
5385 args = build_non_dependent_args (orig_args);
5386 }
5387
5388 /* The USER_ARGS are the arguments we will display to users if an
5389 error occurs. The USER_ARGS should not include any
5390 compiler-generated arguments. The "this" pointer hasn't been
5391 added yet. However, we must remove the VTT pointer if this is a
5392 call to a base-class constructor or destructor. */
5393 user_args = args;
5394 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5395 {
5396 /* Callers should explicitly indicate whether they want to construct
5397 the complete object or just the part without virtual bases. */
5398 gcc_assert (name != ctor_identifier);
5399 /* Similarly for destructors. */
5400 gcc_assert (name != dtor_identifier);
5401 /* Remove the VTT pointer, if present. */
5402 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5403 && CLASSTYPE_VBASECLASSES (basetype))
5404 user_args = TREE_CHAIN (user_args);
5405 }
5406
5407 /* Process the argument list. */
5408 args = resolve_args (args);
5409 if (args == error_mark_node)
5410 return error_mark_node;
5411
5412 instance_ptr = build_this (instance);
5413
5414 /* It's OK to call destructors on cv-qualified objects. Therefore,
5415 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5416 if (DECL_DESTRUCTOR_P (fn))
5417 {
5418 tree type = build_pointer_type (basetype);
5419 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5420 instance_ptr = build_nop (type, instance_ptr);
5421 name = complete_dtor_identifier;
5422 }
5423
5424 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5425 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5426
5427 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5428 p = conversion_obstack_alloc (0);
5429
5430 for (fn = fns; fn; fn = OVL_NEXT (fn))
5431 {
5432 tree t = OVL_CURRENT (fn);
5433 tree this_arglist;
5434
5435 /* We can end up here for copy-init of same or base class. */
5436 if ((flags & LOOKUP_ONLYCONVERTING)
5437 && DECL_NONCONVERTING_P (t))
5438 continue;
5439
5440 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5441 this_arglist = mem_args;
5442 else
5443 this_arglist = args;
5444
5445 if (TREE_CODE (t) == TEMPLATE_DECL)
5446 /* A member template. */
5447 add_template_candidate (&candidates, t,
5448 class_type,
5449 explicit_targs,
5450 this_arglist, optype,
5451 access_binfo,
5452 conversion_path,
5453 flags,
5454 DEDUCE_CALL);
5455 else if (! template_only)
5456 add_function_candidate (&candidates, t,
5457 class_type,
5458 this_arglist,
5459 access_binfo,
5460 conversion_path,
5461 flags);
5462 }
5463
5464 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5465 if (!any_viable_p)
5466 {
5467 if (!COMPLETE_TYPE_P (basetype))
5468 cxx_incomplete_type_error (instance_ptr, basetype);
5469 else
5470 {
5471 char *pretty_name;
5472 bool free_p;
5473
5474 pretty_name = name_as_c_string (name, basetype, &free_p);
5475 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5476 basetype, pretty_name, user_args,
5477 TREE_TYPE (TREE_TYPE (instance_ptr)));
5478 if (free_p)
5479 free (pretty_name);
5480 }
5481 print_z_candidates (candidates);
5482 call = error_mark_node;
5483 }
5484 else
5485 {
5486 cand = tourney (candidates);
5487 if (cand == 0)
5488 {
5489 char *pretty_name;
5490 bool free_p;
5491
5492 pretty_name = name_as_c_string (name, basetype, &free_p);
5493 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5494 user_args);
5495 print_z_candidates (candidates);
5496 if (free_p)
5497 free (pretty_name);
5498 call = error_mark_node;
5499 }
5500 else
5501 {
5502 fn = cand->fn;
5503
5504 if (!(flags & LOOKUP_NONVIRTUAL)
5505 && DECL_PURE_VIRTUAL_P (fn)
5506 && instance == current_class_ref
5507 && (DECL_CONSTRUCTOR_P (current_function_decl)
5508 || DECL_DESTRUCTOR_P (current_function_decl)))
5509 /* This is not an error, it is runtime undefined
5510 behavior. */
5511 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5512 "abstract virtual %q#D called from constructor"
5513 : "abstract virtual %q#D called from destructor"),
5514 fn);
5515
5516 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5517 && is_dummy_object (instance_ptr))
5518 {
5519 error ("cannot call member function %qD without object",
5520 fn);
5521 call = error_mark_node;
5522 }
5523 else
5524 {
5525 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5526 && resolves_to_fixed_type_p (instance, 0))
5527 flags |= LOOKUP_NONVIRTUAL;
5528 /* Now we know what function is being called. */
5529 if (fn_p)
5530 *fn_p = fn;
5531 /* Build the actual CALL_EXPR. */
5532 call = build_over_call (cand, flags);
5533 /* In an expression of the form `a->f()' where `f' turns
5534 out to be a static member function, `a' is
5535 none-the-less evaluated. */
5536 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5537 && !is_dummy_object (instance_ptr)
5538 && TREE_SIDE_EFFECTS (instance_ptr))
5539 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5540 instance_ptr, call);
5541 else if (call != error_mark_node
5542 && DECL_DESTRUCTOR_P (cand->fn)
5543 && !VOID_TYPE_P (TREE_TYPE (call)))
5544 /* An explicit call of the form "x->~X()" has type
5545 "void". However, on platforms where destructors
5546 return "this" (i.e., those where
5547 targetm.cxx.cdtor_returns_this is true), such calls
5548 will appear to have a return value of pointer type
5549 to the low-level call machinery. We do not want to
5550 change the low-level machinery, since we want to be
5551 able to optimize "delete f()" on such platforms as
5552 "operator delete(~X(f()))" (rather than generating
5553 "t = f(), ~X(t), operator delete (t)"). */
5554 call = build_nop (void_type_node, call);
5555 }
5556 }
5557 }
5558
5559 if (processing_template_decl && call != error_mark_node)
5560 call = (build_min_non_dep
5561 (CALL_EXPR, call,
5562 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5563 orig_args, NULL_TREE));
5564
5565 /* Free all the conversions we allocated. */
5566 obstack_free (&conversion_obstack, p);
5567
5568 return call;
5569}
5570
5571/* Returns true iff standard conversion sequence ICS1 is a proper
5572 subsequence of ICS2. */
5573
5574static bool
5575is_subseq (conversion *ics1, conversion *ics2)
5576{
5577 /* We can assume that a conversion of the same code
5578 between the same types indicates a subsequence since we only get
5579 here if the types we are converting from are the same. */
5580
5581 while (ics1->kind == ck_rvalue
5582 || ics1->kind == ck_lvalue)
5583 ics1 = ics1->u.next;
5584
5585 while (1)
5586 {
5587 while (ics2->kind == ck_rvalue
5588 || ics2->kind == ck_lvalue)
5589 ics2 = ics2->u.next;
5590
5591 if (ics2->kind == ck_user
5592 || ics2->kind == ck_ambig
5593 || ics2->kind == ck_identity)
5594 /* At this point, ICS1 cannot be a proper subsequence of
5595 ICS2. We can get a USER_CONV when we are comparing the
5596 second standard conversion sequence of two user conversion
5597 sequences. */
5598 return false;
5599
5600 ics2 = ics2->u.next;
5601
5602 if (ics2->kind == ics1->kind
5603 && same_type_p (ics2->type, ics1->type)
5604 && same_type_p (ics2->u.next->type,
5605 ics1->u.next->type))
5606 return true;
5607 }
5608}
5609
5610/* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5611 be any _TYPE nodes. */
5612
5613bool
5614is_properly_derived_from (tree derived, tree base)
5615{
5616 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5617 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5618 return false;
5619
5620 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5621 considers every class derived from itself. */
5622 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5623 && DERIVED_FROM_P (base, derived));
5624}
5625
5626/* We build the ICS for an implicit object parameter as a pointer
5627 conversion sequence. However, such a sequence should be compared
5628 as if it were a reference conversion sequence. If ICS is the
5629 implicit conversion sequence for an implicit object parameter,
5630 modify it accordingly. */
5631
5632static void
5633maybe_handle_implicit_object (conversion **ics)
5634{
5635 if ((*ics)->this_p)
5636 {
5637 /* [over.match.funcs]
5638
5639 For non-static member functions, the type of the
5640 implicit object parameter is "reference to cv X"
5641 where X is the class of which the function is a
5642 member and cv is the cv-qualification on the member
5643 function declaration. */
5644 conversion *t = *ics;
5645 tree reference_type;
5646
5647 /* The `this' parameter is a pointer to a class type. Make the
5648 implicit conversion talk about a reference to that same class
5649 type. */
5650 reference_type = TREE_TYPE (t->type);
5651 reference_type = build_reference_type (reference_type);
5652
5653 if (t->kind == ck_qual)
5654 t = t->u.next;
5655 if (t->kind == ck_ptr)
5656 t = t->u.next;
5657 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5658 t = direct_reference_binding (reference_type, t);
5659 *ics = t;
5660 }
5661}
5662
5663/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5664 and return the type to which the reference refers. Otherwise,
5665 leave *ICS unchanged and return NULL_TREE. */
5666
5667static tree
5668maybe_handle_ref_bind (conversion **ics)
5669{
5670 if ((*ics)->kind == ck_ref_bind)
5671 {
5672 conversion *old_ics = *ics;
5673 tree type = TREE_TYPE (old_ics->type);
5674 *ics = old_ics->u.next;
5675 (*ics)->user_conv_p = old_ics->user_conv_p;
5676 (*ics)->bad_p = old_ics->bad_p;
5677 return type;
5678 }
5679
5680 return NULL_TREE;
5681}
5682
5683/* Compare two implicit conversion sequences according to the rules set out in
5684 [over.ics.rank]. Return values:
5685
5686 1: ics1 is better than ics2
5687 -1: ics2 is better than ics1
5688 0: ics1 and ics2 are indistinguishable */
5689
5690static int
5691compare_ics (conversion *ics1, conversion *ics2)
5692{
5693 tree from_type1;
5694 tree from_type2;
5695 tree to_type1;
5696 tree to_type2;
5697 tree deref_from_type1 = NULL_TREE;
5698 tree deref_from_type2 = NULL_TREE;
5699 tree deref_to_type1 = NULL_TREE;
5700 tree deref_to_type2 = NULL_TREE;
5701 conversion_rank rank1, rank2;
5702
5703 /* REF_BINDING is nonzero if the result of the conversion sequence
5704 is a reference type. In that case TARGET_TYPE is the
5705 type referred to by the reference. */
5706 tree target_type1;
5707 tree target_type2;
5708
5709 /* Handle implicit object parameters. */
5710 maybe_handle_implicit_object (&ics1);
5711 maybe_handle_implicit_object (&ics2);
5712
5713 /* Handle reference parameters. */
5714 target_type1 = maybe_handle_ref_bind (&ics1);
5715 target_type2 = maybe_handle_ref_bind (&ics2);
5716
5717 /* [over.ics.rank]
5718
5719 When comparing the basic forms of implicit conversion sequences (as
5720 defined in _over.best.ics_)
5721
5722 --a standard conversion sequence (_over.ics.scs_) is a better
5723 conversion sequence than a user-defined conversion sequence
5724 or an ellipsis conversion sequence, and
5725
5726 --a user-defined conversion sequence (_over.ics.user_) is a
5727 better conversion sequence than an ellipsis conversion sequence
5728 (_over.ics.ellipsis_). */
5729 rank1 = CONVERSION_RANK (ics1);
5730 rank2 = CONVERSION_RANK (ics2);
5731
5732 if (rank1 > rank2)
5733 return -1;
5734 else if (rank1 < rank2)
5735 return 1;
5736
5737 if (rank1 == cr_bad)
5738 {
5739 /* XXX Isn't this an extension? */
5740 /* Both ICS are bad. We try to make a decision based on what
5741 would have happened if they'd been good. */
5742 if (ics1->user_conv_p > ics2->user_conv_p
5743 || ics1->rank > ics2->rank)
5744 return -1;
5745 else if (ics1->user_conv_p < ics2->user_conv_p
5746 || ics1->rank < ics2->rank)
5747 return 1;
5748
5749 /* We couldn't make up our minds; try to figure it out below. */
5750 }
5751
5752 if (ics1->ellipsis_p)
5753 /* Both conversions are ellipsis conversions. */
5754 return 0;
5755
5756 /* User-defined conversion sequence U1 is a better conversion sequence
5757 than another user-defined conversion sequence U2 if they contain the
5758 same user-defined conversion operator or constructor and if the sec-
5759 ond standard conversion sequence of U1 is better than the second
5760 standard conversion sequence of U2. */
5761
5762 if (ics1->user_conv_p)
5763 {
5764 conversion *t1;
5765 conversion *t2;
5766
5767 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5768 if (t1->kind == ck_ambig)
5769 return 0;
5770 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5771 if (t2->kind == ck_ambig)
5772 return 0;
5773
5774 if (t1->cand->fn != t2->cand->fn)
5775 return 0;
5776
5777 /* We can just fall through here, after setting up
5778 FROM_TYPE1 and FROM_TYPE2. */
5779 from_type1 = t1->type;
5780 from_type2 = t2->type;
5781 }
5782 else
5783 {
5784 conversion *t1;
5785 conversion *t2;
5786
5787 /* We're dealing with two standard conversion sequences.
5788
5789 [over.ics.rank]
5790
5791 Standard conversion sequence S1 is a better conversion
5792 sequence than standard conversion sequence S2 if
5793
5794 --S1 is a proper subsequence of S2 (comparing the conversion
5795 sequences in the canonical form defined by _over.ics.scs_,
5796 excluding any Lvalue Transformation; the identity
5797 conversion sequence is considered to be a subsequence of
5798 any non-identity conversion sequence */
5799
5800 t1 = ics1;
5801 while (t1->kind != ck_identity)
5802 t1 = t1->u.next;
5803 from_type1 = t1->type;
5804
5805 t2 = ics2;
5806 while (t2->kind != ck_identity)
5807 t2 = t2->u.next;
5808 from_type2 = t2->type;
5809 }
5810
5811 if (same_type_p (from_type1, from_type2))
5812 {
5813 if (is_subseq (ics1, ics2))
5814 return 1;
5815 if (is_subseq (ics2, ics1))
5816 return -1;
5817 }
5818 /* Otherwise, one sequence cannot be a subsequence of the other; they
5819 don't start with the same type. This can happen when comparing the
5820 second standard conversion sequence in two user-defined conversion
5821 sequences. */
5822
5823 /* [over.ics.rank]
5824
5825 Or, if not that,
5826
5827 --the rank of S1 is better than the rank of S2 (by the rules
5828 defined below):
5829
5830 Standard conversion sequences are ordered by their ranks: an Exact
5831 Match is a better conversion than a Promotion, which is a better
5832 conversion than a Conversion.
5833
5834 Two conversion sequences with the same rank are indistinguishable
5835 unless one of the following rules applies:
5836
5837 --A conversion that is not a conversion of a pointer, or pointer
5838 to member, to bool is better than another conversion that is such
5839 a conversion.
5840
5841 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5842 so that we do not have to check it explicitly. */
5843 if (ics1->rank < ics2->rank)
5844 return 1;
5845 else if (ics2->rank < ics1->rank)
5846 return -1;
5847
5848 to_type1 = ics1->type;
5849 to_type2 = ics2->type;
5850
5851 if (TYPE_PTR_P (from_type1)
5852 && TYPE_PTR_P (from_type2)
5853 && TYPE_PTR_P (to_type1)
5854 && TYPE_PTR_P (to_type2))
5855 {
5856 deref_from_type1 = TREE_TYPE (from_type1);
5857 deref_from_type2 = TREE_TYPE (from_type2);
5858 deref_to_type1 = TREE_TYPE (to_type1);
5859 deref_to_type2 = TREE_TYPE (to_type2);
5860 }
5861 /* The rules for pointers to members A::* are just like the rules
5862 for pointers A*, except opposite: if B is derived from A then
5863 A::* converts to B::*, not vice versa. For that reason, we
5864 switch the from_ and to_ variables here. */
5865 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5866 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5867 || (TYPE_PTRMEMFUNC_P (from_type1)
5868 && TYPE_PTRMEMFUNC_P (from_type2)
5869 && TYPE_PTRMEMFUNC_P (to_type1)
5870 && TYPE_PTRMEMFUNC_P (to_type2)))
5871 {
5872 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5873 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5874 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5875 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5876 }
5877
5878 if (deref_from_type1 != NULL_TREE
5879 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5880 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5881 {
5882 /* This was one of the pointer or pointer-like conversions.
5883
5884 [over.ics.rank]
5885
5886 --If class B is derived directly or indirectly from class A,
5887 conversion of B* to A* is better than conversion of B* to
5888 void*, and conversion of A* to void* is better than
5889 conversion of B* to void*. */
5890 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5891 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5892 {
5893 if (is_properly_derived_from (deref_from_type1,
5894 deref_from_type2))
5895 return -1;
5896 else if (is_properly_derived_from (deref_from_type2,
5897 deref_from_type1))
5898 return 1;
5899 }
5900 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5901 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5902 {
5903 if (same_type_p (deref_from_type1, deref_from_type2))
5904 {
5905 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5906 {
5907 if (is_properly_derived_from (deref_from_type1,
5908 deref_to_type1))
5909 return 1;
5910 }
5911 /* We know that DEREF_TO_TYPE1 is `void' here. */
5912 else if (is_properly_derived_from (deref_from_type1,
5913 deref_to_type2))
5914 return -1;
5915 }
5916 }
5917 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5918 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5919 {
5920 /* [over.ics.rank]
5921
5922 --If class B is derived directly or indirectly from class A
5923 and class C is derived directly or indirectly from B,
5924
5925 --conversion of C* to B* is better than conversion of C* to
5926 A*,
5927
5928 --conversion of B* to A* is better than conversion of C* to
5929 A* */
5930 if (same_type_p (deref_from_type1, deref_from_type2))
5931 {
5932 if (is_properly_derived_from (deref_to_type1,
5933 deref_to_type2))
5934 return 1;
5935 else if (is_properly_derived_from (deref_to_type2,
5936 deref_to_type1))
5937 return -1;
5938 }
5939 else if (same_type_p (deref_to_type1, deref_to_type2))
5940 {
5941 if (is_properly_derived_from (deref_from_type2,
5942 deref_from_type1))
5943 return 1;
5944 else if (is_properly_derived_from (deref_from_type1,
5945 deref_from_type2))
5946 return -1;
5947 }
5948 }
5949 }
5950 else if (CLASS_TYPE_P (non_reference (from_type1))
5951 && same_type_p (from_type1, from_type2))
5952 {
5953 tree from = non_reference (from_type1);
5954
5955 /* [over.ics.rank]
5956
5957 --binding of an expression of type C to a reference of type
5958 B& is better than binding an expression of type C to a
5959 reference of type A&
5960
5961 --conversion of C to B is better than conversion of C to A, */
5962 if (is_properly_derived_from (from, to_type1)
5963 && is_properly_derived_from (from, to_type2))
5964 {
5965 if (is_properly_derived_from (to_type1, to_type2))
5966 return 1;
5967 else if (is_properly_derived_from (to_type2, to_type1))
5968 return -1;
5969 }
5970 }
5971 else if (CLASS_TYPE_P (non_reference (to_type1))
5972 && same_type_p (to_type1, to_type2))
5973 {
5974 tree to = non_reference (to_type1);
5975
5976 /* [over.ics.rank]
5977
5978 --binding of an expression of type B to a reference of type
5979 A& is better than binding an expression of type C to a
5980 reference of type A&,
5981
5982 --conversion of B to A is better than conversion of C to A */
5983 if (is_properly_derived_from (from_type1, to)
5984 && is_properly_derived_from (from_type2, to))
5985 {
5986 if (is_properly_derived_from (from_type2, from_type1))
5987 return 1;
5988 else if (is_properly_derived_from (from_type1, from_type2))
5989 return -1;
5990 }
5991 }
5992
5993 /* [over.ics.rank]
5994
5995 --S1 and S2 differ only in their qualification conversion and yield
5996 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
5997 qualification signature of type T1 is a proper subset of the cv-
5998 qualification signature of type T2 */
5999 if (ics1->kind == ck_qual
6000 && ics2->kind == ck_qual
6001 && same_type_p (from_type1, from_type2))
6002 return comp_cv_qual_signature (to_type1, to_type2);
6003
6004 /* [over.ics.rank]
6005
6006 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6007 types to which the references refer are the same type except for
6008 top-level cv-qualifiers, and the type to which the reference
6009 initialized by S2 refers is more cv-qualified than the type to
6010 which the reference initialized by S1 refers */
6011
6012 if (target_type1 && target_type2
6013 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6014 return comp_cv_qualification (target_type2, target_type1);
6015
6016 /* Neither conversion sequence is better than the other. */
6017 return 0;
6018}
6019
6020/* The source type for this standard conversion sequence. */
6021
6022static tree
6023source_type (conversion *t)
6024{
6025 for (;; t = t->u.next)
6026 {
6027 if (t->kind == ck_user
6028 || t->kind == ck_ambig
6029 || t->kind == ck_identity)
6030 return t->type;
6031 }
6032 gcc_unreachable ();
6033}
6034
6035/* Note a warning about preferring WINNER to LOSER. We do this by storing
6036 a pointer to LOSER and re-running joust to produce the warning if WINNER
6037 is actually used. */
6038
6039static void
6040add_warning (struct z_candidate *winner, struct z_candidate *loser)
6041{
6042 candidate_warning *cw = (candidate_warning *)
6043 conversion_obstack_alloc (sizeof (candidate_warning));
6044 cw->loser = loser;
6045 cw->next = winner->warnings;
6046 winner->warnings = cw;
6047}
6048
6049/* Compare two candidates for overloading as described in
6050 [over.match.best]. Return values:
6051
6052 1: cand1 is better than cand2
6053 -1: cand2 is better than cand1
6054 0: cand1 and cand2 are indistinguishable */
6055
6056static int
6057joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6058{
6059 int winner = 0;
6060 int off1 = 0, off2 = 0;
6061 size_t i;
6062 size_t len;
6063
6064 /* Candidates that involve bad conversions are always worse than those
6065 that don't. */
6066 if (cand1->viable > cand2->viable)
6067 return 1;
6068 if (cand1->viable < cand2->viable)
6069 return -1;
6070
6071 /* If we have two pseudo-candidates for conversions to the same type,
6072 or two candidates for the same function, arbitrarily pick one. */
6073 if (cand1->fn == cand2->fn
6074 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6075 return 1;
6076
6077 /* a viable function F1
6078 is defined to be a better function than another viable function F2 if
6079 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6080 ICSi(F2), and then */
6081
6082 /* for some argument j, ICSj(F1) is a better conversion sequence than
6083 ICSj(F2) */
6084
6085 /* For comparing static and non-static member functions, we ignore
6086 the implicit object parameter of the non-static function. The
6087 standard says to pretend that the static function has an object
6088 parm, but that won't work with operator overloading. */
6089 len = cand1->num_convs;
6090 if (len != cand2->num_convs)
6091 {
6092 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6093 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6094
6095 gcc_assert (static_1 != static_2);
6096
6097 if (static_1)
6098 off2 = 1;
6099 else
6100 {
6101 off1 = 1;
6102 --len;
6103 }
6104 }
6105
6106 for (i = 0; i < len; ++i)
6107 {
6108 conversion *t1 = cand1->convs[i + off1];
6109 conversion *t2 = cand2->convs[i + off2];
6110 int comp = compare_ics (t1, t2);
6111
6112 if (comp != 0)
6113 {
6114 if (warn_sign_promo
6115 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6116 == cr_std + cr_promotion)
6117 && t1->kind == ck_std
6118 && t2->kind == ck_std
6119 && TREE_CODE (t1->type) == INTEGER_TYPE
6120 && TREE_CODE (t2->type) == INTEGER_TYPE
6121 && (TYPE_PRECISION (t1->type)
6122 == TYPE_PRECISION (t2->type))
6123 && (TYPE_UNSIGNED (t1->u.next->type)
6124 || (TREE_CODE (t1->u.next->type)
6125 == ENUMERAL_TYPE)))
6126 {
6127 tree type = t1->u.next->type;
6128 tree type1, type2;
6129 struct z_candidate *w, *l;
6130 if (comp > 0)
6131 type1 = t1->type, type2 = t2->type,
6132 w = cand1, l = cand2;
6133 else
6134 type1 = t2->type, type2 = t1->type,
6135 w = cand2, l = cand1;
6136
6137 if (warn)
6138 {
6139 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6140 type, type1, type2);
6141 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6142 }
6143 else
6144 add_warning (w, l);
6145 }
6146
6147 if (winner && comp != winner)
6148 {
6149 winner = 0;
6150 goto tweak;
6151 }
6152 winner = comp;
6153 }
6154 }
6155
6156 /* warn about confusing overload resolution for user-defined conversions,
6157 either between a constructor and a conversion op, or between two
6158 conversion ops. */
6159 if (winner && warn_conversion && cand1->second_conv
6160 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6161 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6162 {
6163 struct z_candidate *w, *l;
6164 bool give_warning = false;
6165
6166 if (winner == 1)
6167 w = cand1, l = cand2;
6168 else
6169 w = cand2, l = cand1;
6170
6171 /* We don't want to complain about `X::operator T1 ()'
6172 beating `X::operator T2 () const', when T2 is a no less
6173 cv-qualified version of T1. */
6174 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6175 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6176 {
6177 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6178 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6179
6180 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6181 {
6182 t = TREE_TYPE (t);
6183 f = TREE_TYPE (f);
6184 }
6185 if (!comp_ptr_ttypes (t, f))
6186 give_warning = true;
6187 }
6188 else
6189 give_warning = true;
6190
6191 if (!give_warning)
6192 /*NOP*/;
6193 else if (warn)
6194 {
6195 tree source = source_type (w->convs[0]);
6196 if (! DECL_CONSTRUCTOR_P (w->fn))
6197 source = TREE_TYPE (source);
6198 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6199 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6200 source, w->second_conv->type);
6201 inform (" because conversion sequence for the argument is better");
6202 }
6203 else
6204 add_warning (w, l);
6205 }
6206
6207 if (winner)
6208 return winner;
6209
6210 /* or, if not that,
6211 F1 is a non-template function and F2 is a template function
6212 specialization. */
6213
6214 if (!cand1->template_decl && cand2->template_decl)
6215 return 1;
6216 else if (cand1->template_decl && !cand2->template_decl)
6217 return -1;
6218
6219 /* or, if not that,
6220 F1 and F2 are template functions and the function template for F1 is
6221 more specialized than the template for F2 according to the partial
6222 ordering rules. */
6223
6224 if (cand1->template_decl && cand2->template_decl)
6225 {
6226 winner = more_specialized_fn
6227 (TI_TEMPLATE (cand1->template_decl),
6228 TI_TEMPLATE (cand2->template_decl),
6229 /* [temp.func.order]: The presence of unused ellipsis and default
6230 arguments has no effect on the partial ordering of function
6231 templates. add_function_candidate() will not have
6232 counted the "this" argument for constructors. */
6233 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6234 if (winner)
6235 return winner;
6236 }
6237
6238 /* or, if not that,
6239 the context is an initialization by user-defined conversion (see
6240 _dcl.init_ and _over.match.user_) and the standard conversion
6241 sequence from the return type of F1 to the destination type (i.e.,
6242 the type of the entity being initialized) is a better conversion
6243 sequence than the standard conversion sequence from the return type
6244 of F2 to the destination type. */
6245
6246 if (cand1->second_conv)
6247 {
6248 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6249 if (winner)
6250 return winner;
6251 }
6252
6253 /* Check whether we can discard a builtin candidate, either because we
6254 have two identical ones or matching builtin and non-builtin candidates.
6255
6256 (Pedantically in the latter case the builtin which matched the user
6257 function should not be added to the overload set, but we spot it here.
6258
6259 [over.match.oper]
6260 ... the builtin candidates include ...
6261 - do not have the same parameter type list as any non-template
6262 non-member candidate. */
6263
6264 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6265 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6266 {
6267 for (i = 0; i < len; ++i)
6268 if (!same_type_p (cand1->convs[i]->type,
6269 cand2->convs[i]->type))
6270 break;
6271 if (i == cand1->num_convs)
6272 {
6273 if (cand1->fn == cand2->fn)
6274 /* Two built-in candidates; arbitrarily pick one. */
6275 return 1;
6276 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6277 /* cand1 is built-in; prefer cand2. */
6278 return -1;
6279 else
6280 /* cand2 is built-in; prefer cand1. */
6281 return 1;
6282 }
6283 }
6284
6285 /* If the two functions are the same (this can happen with declarations
6286 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6287 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6288 && equal_functions (cand1->fn, cand2->fn))
6289 return 1;
6290
6291tweak:
6292
6293 /* Extension: If the worst conversion for one candidate is worse than the
6294 worst conversion for the other, take the first. */
6295 if (!pedantic)
6296 {
6297 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6298 struct z_candidate *w = 0, *l = 0;
6299
6300 for (i = 0; i < len; ++i)
6301 {
6302 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6303 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6304 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6305 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6306 }
6307 if (rank1 < rank2)
6308 winner = 1, w = cand1, l = cand2;
6309 if (rank1 > rank2)
6310 winner = -1, w = cand2, l = cand1;
6311 if (winner)
6312 {
6313 if (warn)
6314 {
6315 pedwarn ("\
6316ISO C++ says that these are ambiguous, even \
6317though the worst conversion for the first is better than \
6318the worst conversion for the second:");
6319 print_z_candidate (_("candidate 1:"), w);
6320 print_z_candidate (_("candidate 2:"), l);
6321 }
6322 else
6323 add_warning (w, l);
6324 return winner;
6325 }
6326 }
6327
6328 gcc_assert (!winner);
6329 return 0;
6330}
6331
6332/* Given a list of candidates for overloading, find the best one, if any.
6333 This algorithm has a worst case of O(2n) (winner is last), and a best
6334 case of O(n/2) (totally ambiguous); much better than a sorting
6335 algorithm. */
6336
6337static struct z_candidate *
6338tourney (struct z_candidate *candidates)
6339{
6340 struct z_candidate *champ = candidates, *challenger;
6341 int fate;
6342 int champ_compared_to_predecessor = 0;
6343
6344 /* Walk through the list once, comparing each current champ to the next
6345 candidate, knocking out a candidate or two with each comparison. */
6346
6347 for (challenger = champ->next; challenger; )
6348 {
6349 fate = joust (champ, challenger, 0);
6350 if (fate == 1)
6351 challenger = challenger->next;
6352 else
6353 {
6354 if (fate == 0)
6355 {
6356 champ = challenger->next;
6357 if (champ == 0)
6358 return NULL;
6359 champ_compared_to_predecessor = 0;
6360 }
6361 else
6362 {
6363 champ = challenger;
6364 champ_compared_to_predecessor = 1;
6365 }
6366
6367 challenger = champ->next;
6368 }
6369 }
6370
6371 /* Make sure the champ is better than all the candidates it hasn't yet
6372 been compared to. */
6373
6374 for (challenger = candidates;
6375 challenger != champ
6376 && !(champ_compared_to_predecessor && challenger->next == champ);
6377 challenger = challenger->next)
6378 {
6379 fate = joust (champ, challenger, 0);
6380 if (fate != 1)
6381 return NULL;
6382 }
6383
6384 return champ;
6385}
6386
6387/* Returns nonzero if things of type FROM can be converted to TO. */
6388
6389bool
6390can_convert (tree to, tree from)
6391{
6392 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6393}
6394
6395/* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6396
6397bool
6398can_convert_arg (tree to, tree from, tree arg, int flags)
6399{
6400 conversion *t;
6401 void *p;
6402 bool ok_p;
6403
6404 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6405 p = conversion_obstack_alloc (0);
6406
6407 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6408 flags);
6409 ok_p = (t && !t->bad_p);
6410
6411 /* Free all the conversions we allocated. */
6412 obstack_free (&conversion_obstack, p);
6413
6414 return ok_p;
6415}
6416
6417/* Like can_convert_arg, but allows dubious conversions as well. */
6418
6419bool
6420can_convert_arg_bad (tree to, tree from, tree arg)
6421{
6422 conversion *t;
6423 void *p;
6424
6425 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6426 p = conversion_obstack_alloc (0);
6427 /* Try to perform the conversion. */
6428 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6429 LOOKUP_NORMAL);
6430 /* Free all the conversions we allocated. */
6431 obstack_free (&conversion_obstack, p);
6432
6433 return t != NULL;
6434}
6435
6436/* Convert EXPR to TYPE. Return the converted expression.
6437
6438 Note that we allow bad conversions here because by the time we get to
6439 this point we are committed to doing the conversion. If we end up
6440 doing a bad conversion, convert_like will complain. */
6441
6442tree
6443perform_implicit_conversion (tree type, tree expr)
6444{
6445 conversion *conv;
6446 void *p;
6447
6448 if (error_operand_p (expr))
6449 return error_mark_node;
6450
6451 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6452 p = conversion_obstack_alloc (0);
6453
6454 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6455 /*c_cast_p=*/false,
6456 LOOKUP_NORMAL);
6457 if (!conv)
6458 {
6459 error ("could not convert %qE to %qT", expr, type);
6460 expr = error_mark_node;
6461 }
6462 else if (processing_template_decl)
6463 {
6464 /* In a template, we are only concerned about determining the
6465 type of non-dependent expressions, so we do not have to
6466 perform the actual conversion. */
6467 if (TREE_TYPE (expr) != type)
6468 expr = build_nop (type, expr);
6469 }
6470 else
6471 expr = convert_like (conv, expr);
6472
6473 /* Free all the conversions we allocated. */
6474 obstack_free (&conversion_obstack, p);
6475
6476 return expr;
6477}
6478
6479/* Convert EXPR to TYPE (as a direct-initialization) if that is
6480 permitted. If the conversion is valid, the converted expression is
6481 returned. Otherwise, NULL_TREE is returned, except in the case
6482 that TYPE is a class type; in that case, an error is issued. If
6483 C_CAST_P is true, then this direction initialization is taking
6484 place as part of a static_cast being attempted as part of a C-style
6485 cast. */
6486
6487tree
6488perform_direct_initialization_if_possible (tree type,
6489 tree expr,
6490 bool c_cast_p)
6491{
6492 conversion *conv;
6493 void *p;
6494
6495 if (type == error_mark_node || error_operand_p (expr))
6496 return error_mark_node;
6497 /* [dcl.init]
6498
6499 If the destination type is a (possibly cv-qualified) class type:
6500
6501 -- If the initialization is direct-initialization ...,
6502 constructors are considered. ... If no constructor applies, or
6503 the overload resolution is ambiguous, the initialization is
6504 ill-formed. */
6505 if (CLASS_TYPE_P (type))
6506 {
6507 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6508 build_tree_list (NULL_TREE, expr),
6509 type, LOOKUP_NORMAL);
6510 return build_cplus_new (type, expr);
6511 }
6512
6513 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6514 p = conversion_obstack_alloc (0);
6515
6516 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6517 c_cast_p,
6518 LOOKUP_NORMAL);
6519 if (!conv || conv->bad_p)
6520 expr = NULL_TREE;
6521 else
6522 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6523 /*issue_conversion_warnings=*/false,
6524 c_cast_p);
6525
6526 /* Free all the conversions we allocated. */
6527 obstack_free (&conversion_obstack, p);
6528
6529 return expr;
6530}
6531
6532/* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6533 is being bound to a temporary. Create and return a new VAR_DECL
6534 with the indicated TYPE; this variable will store the value to
6535 which the reference is bound. */
6536
6537tree
6538make_temporary_var_for_ref_to_temp (tree decl, tree type)
6539{
6540 tree var;
6541
6542 /* Create the variable. */
6543 var = create_temporary_var (type);
6544
6545 /* Register the variable. */
6546 if (TREE_STATIC (decl))
6547 {
6548 /* Namespace-scope or local static; give it a mangled name. */
6549 tree name;
6550
6551 TREE_STATIC (var) = 1;
6552 name = mangle_ref_init_variable (decl);
6553 DECL_NAME (var) = name;
6554 SET_DECL_ASSEMBLER_NAME (var, name);
6555 var = pushdecl_top_level (var);
6556 }
6557 else
6558 /* Create a new cleanup level if necessary. */
6559 maybe_push_cleanup_level (type);
6560
6561 return var;
6562}
6563
6564/* Convert EXPR to the indicated reference TYPE, in a way suitable for
6565 initializing a variable of that TYPE. If DECL is non-NULL, it is
6566 the VAR_DECL being initialized with the EXPR. (In that case, the
6567 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6568 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6569 return, if *CLEANUP is no longer NULL, it will be an expression
6570 that should be pushed as a cleanup after the returned expression
6571 is used to initialize DECL.
6572
6573 Return the converted expression. */
6574
6575tree
6576initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6577{
6578 conversion *conv;
6579 void *p;
6580
6581 if (type == error_mark_node || error_operand_p (expr))
6582 return error_mark_node;
6583
6584 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6585 p = conversion_obstack_alloc (0);
6586
6587 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
6588 LOOKUP_NORMAL);
6589 if (!conv || conv->bad_p)
6590 {
6591 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6592 && !real_lvalue_p (expr))
6593 error ("invalid initialization of non-const reference of "
6594 "type %qT from a temporary of type %qT",
6595 type, TREE_TYPE (expr));
6596 else
6597 error ("invalid initialization of reference of type "
6598 "%qT from expression of type %qT", type,
6599 TREE_TYPE (expr));
6600 return error_mark_node;
6601 }
6602
6603 /* If DECL is non-NULL, then this special rule applies:
6604
6605 [class.temporary]
6606
6607 The temporary to which the reference is bound or the temporary
6608 that is the complete object to which the reference is bound
6609 persists for the lifetime of the reference.
6610
6611 The temporaries created during the evaluation of the expression
6612 initializing the reference, except the temporary to which the
6613 reference is bound, are destroyed at the end of the
6614 full-expression in which they are created.
6615
6616 In that case, we store the converted expression into a new
6617 VAR_DECL in a new scope.
6618
6619 However, we want to be careful not to create temporaries when
6620 they are not required. For example, given:
6621
6622 struct B {};
6623 struct D : public B {};
6624 D f();
6625 const B& b = f();
6626
6627 there is no need to copy the return value from "f"; we can just
6628 extend its lifetime. Similarly, given:
6629
6630 struct S {};
6631 struct T { operator S(); };
6632 T t;
6633 const S& s = t;
6634
6635 we can extend the lifetime of the return value of the conversion
6636 operator. */
6637 gcc_assert (conv->kind == ck_ref_bind);
6638 if (decl)
6639 {
6640 tree var;
6641 tree base_conv_type;
6642
6643 /* Skip over the REF_BIND. */
6644 conv = conv->u.next;
6645 /* If the next conversion is a BASE_CONV, skip that too -- but
6646 remember that the conversion was required. */
6647 if (conv->kind == ck_base)
6648 {
6649 if (conv->check_copy_constructor_p)
6650 check_constructor_callable (TREE_TYPE (expr), expr);
6651 base_conv_type = conv->type;
6652 conv = conv->u.next;
6653 }
6654 else
6655 base_conv_type = NULL_TREE;
6656 /* Perform the remainder of the conversion. */
6657 expr = convert_like_real (conv, expr,
6658 /*fn=*/NULL_TREE, /*argnum=*/0,
6659 /*inner=*/-1,
6660 /*issue_conversion_warnings=*/true,
6661 /*c_cast_p=*/false);
6662 if (error_operand_p (expr))
6663 expr = error_mark_node;
6664 else
6665 {
6666 if (!real_lvalue_p (expr))
6667 {
6668 tree init;
6669 tree type;
6670
6671 /* Create the temporary variable. */
6672 type = TREE_TYPE (expr);
6673 var = make_temporary_var_for_ref_to_temp (decl, type);
6674 layout_decl (var, 0);
6675 /* If the rvalue is the result of a function call it will be
6676 a TARGET_EXPR. If it is some other construct (such as a
6677 member access expression where the underlying object is
6678 itself the result of a function call), turn it into a
6679 TARGET_EXPR here. It is important that EXPR be a
6680 TARGET_EXPR below since otherwise the INIT_EXPR will
6681 attempt to make a bitwise copy of EXPR to initialize
6682 VAR. */
6683 if (TREE_CODE (expr) != TARGET_EXPR)
6684 expr = get_target_expr (expr);
6685 /* Create the INIT_EXPR that will initialize the temporary
6686 variable. */
6687 init = build2 (INIT_EXPR, type, var, expr);
6688 if (at_function_scope_p ())
6689 {
6690 add_decl_expr (var);
6691 *cleanup = cxx_maybe_build_cleanup (var);
6692
6693 /* We must be careful to destroy the temporary only
6694 after its initialization has taken place. If the
6695 initialization throws an exception, then the
6696 destructor should not be run. We cannot simply
6697 transform INIT into something like:
6698
6699 (INIT, ({ CLEANUP_STMT; }))
6700
6701 because emit_local_var always treats the
6702 initializer as a full-expression. Thus, the
6703 destructor would run too early; it would run at the
6704 end of initializing the reference variable, rather
6705 than at the end of the block enclosing the
6706 reference variable.
6707
6708 The solution is to pass back a cleanup expression
6709 which the caller is responsible for attaching to
6710 the statement tree. */
6711 }
6712 else
6713 {
6714 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6715 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6716 static_aggregates = tree_cons (NULL_TREE, var,
6717 static_aggregates);
6718 }
6719 /* Use its address to initialize the reference variable. */
6720 expr = build_address (var);
6721 if (base_conv_type)
6722 expr = convert_to_base (expr,
6723 build_pointer_type (base_conv_type),
6724 /*check_access=*/true,
6725 /*nonnull=*/true);
6726 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6727 }
6728 else
6729 /* Take the address of EXPR. */
6730 expr = build_unary_op (ADDR_EXPR, expr, 0);
6731 /* If a BASE_CONV was required, perform it now. */
6732 if (base_conv_type)
6733 expr = (perform_implicit_conversion
6734 (build_pointer_type (base_conv_type), expr));
6735 expr = build_nop (type, expr);
6736 }
6737 }
6738 else
6739 /* Perform the conversion. */
6740 expr = convert_like (conv, expr);
6741
6742 /* Free all the conversions we allocated. */
6743 obstack_free (&conversion_obstack, p);
6744
6745 return expr;
6746}
6747
6748#include "gt-cp-call.h"
| 4698 if (val == error_mark_node)
4699 ;
4700 /* Pass classes with copy ctors by invisible reference. */
4701 else if (TREE_ADDRESSABLE (type))
4702 val = build1 (ADDR_EXPR, build_reference_type (type), val);
4703 else if (targetm.calls.promote_prototypes (type)
4704 && INTEGRAL_TYPE_P (type)
4705 && COMPLETE_TYPE_P (type)
4706 && INT_CST_LT_UNSIGNED (TYPE_SIZE (type),
4707 TYPE_SIZE (integer_type_node)))
4708 val = perform_integral_promotions (val);
4709 if (warn_missing_format_attribute)
4710 {
4711 tree rhstype = TREE_TYPE (val);
4712 const enum tree_code coder = TREE_CODE (rhstype);
4713 const enum tree_code codel = TREE_CODE (type);
4714 if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4715 && coder == codel
4716 && check_missing_format_attribute (type, rhstype))
4717 warning (OPT_Wmissing_format_attribute,
4718 "argument of function call might be a candidate for a format attribute");
4719 }
4720 return val;
4721}
4722
4723/* Returns true iff FN is a function with magic varargs, i.e. ones for
4724 which no conversions at all should be done. This is true for some
4725 builtins which don't act like normal functions. */
4726
4727static bool
4728magic_varargs_p (tree fn)
4729{
4730 if (DECL_BUILT_IN (fn))
4731 switch (DECL_FUNCTION_CODE (fn))
4732 {
4733 case BUILT_IN_CLASSIFY_TYPE:
4734 case BUILT_IN_CONSTANT_P:
4735 case BUILT_IN_NEXT_ARG:
4736 case BUILT_IN_STDARG_START:
4737 case BUILT_IN_VA_START:
4738 return true;
4739
4740 default:;
4741 }
4742
4743 return false;
4744}
4745
4746/* Subroutine of the various build_*_call functions. Overload resolution
4747 has chosen a winning candidate CAND; build up a CALL_EXPR accordingly.
4748 ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a
4749 bitmask of various LOOKUP_* flags which apply to the call itself. */
4750
4751static tree
4752build_over_call (struct z_candidate *cand, int flags)
4753{
4754 tree fn = cand->fn;
4755 tree args = cand->args;
4756 conversion **convs = cand->convs;
4757 conversion *conv;
4758 tree converted_args = NULL_TREE;
4759 tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
4760 tree arg, val;
4761 int i = 0;
4762 int is_method = 0;
4763
4764 /* In a template, there is no need to perform all of the work that
4765 is normally done. We are only interested in the type of the call
4766 expression, i.e., the return type of the function. Any semantic
4767 errors will be deferred until the template is instantiated. */
4768 if (processing_template_decl)
4769 {
4770 tree expr;
4771 tree return_type;
4772 return_type = TREE_TYPE (TREE_TYPE (fn));
4773 expr = build3 (CALL_EXPR, return_type, fn, args, NULL_TREE);
4774 if (TREE_THIS_VOLATILE (fn) && cfun)
4775 current_function_returns_abnormally = 1;
4776 if (!VOID_TYPE_P (return_type))
4777 require_complete_type (return_type);
4778 return convert_from_reference (expr);
4779 }
4780
4781 /* Give any warnings we noticed during overload resolution. */
4782 if (cand->warnings)
4783 {
4784 struct candidate_warning *w;
4785 for (w = cand->warnings; w; w = w->next)
4786 joust (cand, w->loser, 1);
4787 }
4788
4789 if (DECL_FUNCTION_MEMBER_P (fn))
4790 {
4791 /* If FN is a template function, two cases must be considered.
4792 For example:
4793
4794 struct A {
4795 protected:
4796 template <class T> void f();
4797 };
4798 template <class T> struct B {
4799 protected:
4800 void g();
4801 };
4802 struct C : A, B<int> {
4803 using A::f; // #1
4804 using B<int>::g; // #2
4805 };
4806
4807 In case #1 where `A::f' is a member template, DECL_ACCESS is
4808 recorded in the primary template but not in its specialization.
4809 We check access of FN using its primary template.
4810
4811 In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply
4812 because it is a member of class template B, DECL_ACCESS is
4813 recorded in the specialization `B<int>::g'. We cannot use its
4814 primary template because `B<T>::g' and `B<int>::g' may have
4815 different access. */
4816 if (DECL_TEMPLATE_INFO (fn)
4817 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn)))
4818 perform_or_defer_access_check (cand->access_path,
4819 DECL_TI_TEMPLATE (fn), fn);
4820 else
4821 perform_or_defer_access_check (cand->access_path, fn, fn);
4822 }
4823
4824 if (args && TREE_CODE (args) != TREE_LIST)
4825 args = build_tree_list (NULL_TREE, args);
4826 arg = args;
4827
4828 /* The implicit parameters to a constructor are not considered by overload
4829 resolution, and must be of the proper type. */
4830 if (DECL_CONSTRUCTOR_P (fn))
4831 {
4832 converted_args = tree_cons (NULL_TREE, TREE_VALUE (arg), converted_args);
4833 arg = TREE_CHAIN (arg);
4834 parm = TREE_CHAIN (parm);
4835 /* We should never try to call the abstract constructor. */
4836 gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn));
4837
4838 if (DECL_HAS_VTT_PARM_P (fn))
4839 {
4840 converted_args = tree_cons
4841 (NULL_TREE, TREE_VALUE (arg), converted_args);
4842 arg = TREE_CHAIN (arg);
4843 parm = TREE_CHAIN (parm);
4844 }
4845 }
4846 /* Bypass access control for 'this' parameter. */
4847 else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4848 {
4849 tree parmtype = TREE_VALUE (parm);
4850 tree argtype = TREE_TYPE (TREE_VALUE (arg));
4851 tree converted_arg;
4852 tree base_binfo;
4853
4854 if (convs[i]->bad_p)
4855 pedwarn ("passing %qT as %<this%> argument of %q#D discards qualifiers",
4856 TREE_TYPE (argtype), fn);
4857
4858 /* [class.mfct.nonstatic]: If a nonstatic member function of a class
4859 X is called for an object that is not of type X, or of a type
4860 derived from X, the behavior is undefined.
4861
4862 So we can assume that anything passed as 'this' is non-null, and
4863 optimize accordingly. */
4864 gcc_assert (TREE_CODE (parmtype) == POINTER_TYPE);
4865 /* Convert to the base in which the function was declared. */
4866 gcc_assert (cand->conversion_path != NULL_TREE);
4867 converted_arg = build_base_path (PLUS_EXPR,
4868 TREE_VALUE (arg),
4869 cand->conversion_path,
4870 1);
4871 /* Check that the base class is accessible. */
4872 if (!accessible_base_p (TREE_TYPE (argtype),
4873 BINFO_TYPE (cand->conversion_path), true))
4874 error ("%qT is not an accessible base of %qT",
4875 BINFO_TYPE (cand->conversion_path),
4876 TREE_TYPE (argtype));
4877 /* If fn was found by a using declaration, the conversion path
4878 will be to the derived class, not the base declaring fn. We
4879 must convert from derived to base. */
4880 base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
4881 TREE_TYPE (parmtype), ba_unique, NULL);
4882 converted_arg = build_base_path (PLUS_EXPR, converted_arg,
4883 base_binfo, 1);
4884
4885 converted_args = tree_cons (NULL_TREE, converted_arg, converted_args);
4886 parm = TREE_CHAIN (parm);
4887 arg = TREE_CHAIN (arg);
4888 ++i;
4889 is_method = 1;
4890 }
4891
4892 for (; arg && parm;
4893 parm = TREE_CHAIN (parm), arg = TREE_CHAIN (arg), ++i)
4894 {
4895 tree type = TREE_VALUE (parm);
4896
4897 conv = convs[i];
4898
4899 /* Don't make a copy here if build_call is going to. */
4900 if (conv->kind == ck_rvalue
4901 && !TREE_ADDRESSABLE (complete_type (type)))
4902 conv = conv->u.next;
4903
4904 val = convert_like_with_context
4905 (conv, TREE_VALUE (arg), fn, i - is_method);
4906
4907 val = convert_for_arg_passing (type, val);
4908 converted_args = tree_cons (NULL_TREE, val, converted_args);
4909 }
4910
4911 /* Default arguments */
4912 for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++)
4913 converted_args
4914 = tree_cons (NULL_TREE,
4915 convert_default_arg (TREE_VALUE (parm),
4916 TREE_PURPOSE (parm),
4917 fn, i - is_method),
4918 converted_args);
4919
4920 /* Ellipsis */
4921 for (; arg; arg = TREE_CHAIN (arg))
4922 {
4923 tree a = TREE_VALUE (arg);
4924 if (magic_varargs_p (fn))
4925 /* Do no conversions for magic varargs. */;
4926 else
4927 a = convert_arg_to_ellipsis (a);
4928 converted_args = tree_cons (NULL_TREE, a, converted_args);
4929 }
4930
4931 converted_args = nreverse (converted_args);
4932
4933 check_function_arguments (TYPE_ATTRIBUTES (TREE_TYPE (fn)),
4934 converted_args, TYPE_ARG_TYPES (TREE_TYPE (fn)));
4935
4936 /* Avoid actually calling copy constructors and copy assignment operators,
4937 if possible. */
4938
4939 if (! flag_elide_constructors)
4940 /* Do things the hard way. */;
4941 else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
4942 {
4943 tree targ;
4944 arg = skip_artificial_parms_for (fn, converted_args);
4945 arg = TREE_VALUE (arg);
4946
4947 /* Pull out the real argument, disregarding const-correctness. */
4948 targ = arg;
4949 while (TREE_CODE (targ) == NOP_EXPR
4950 || TREE_CODE (targ) == NON_LVALUE_EXPR
4951 || TREE_CODE (targ) == CONVERT_EXPR)
4952 targ = TREE_OPERAND (targ, 0);
4953 if (TREE_CODE (targ) == ADDR_EXPR)
4954 {
4955 targ = TREE_OPERAND (targ, 0);
4956 if (!same_type_ignoring_top_level_qualifiers_p
4957 (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ)))
4958 targ = NULL_TREE;
4959 }
4960 else
4961 targ = NULL_TREE;
4962
4963 if (targ)
4964 arg = targ;
4965 else
4966 arg = build_indirect_ref (arg, 0);
4967
4968 /* [class.copy]: the copy constructor is implicitly defined even if
4969 the implementation elided its use. */
4970 if (TYPE_HAS_COMPLEX_INIT_REF (DECL_CONTEXT (fn)))
4971 mark_used (fn);
4972
4973 /* If we're creating a temp and we already have one, don't create a
4974 new one. If we're not creating a temp but we get one, use
4975 INIT_EXPR to collapse the temp into our target. Otherwise, if the
4976 ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a
4977 temp or an INIT_EXPR otherwise. */
4978 if (integer_zerop (TREE_VALUE (args)))
4979 {
4980 if (TREE_CODE (arg) == TARGET_EXPR)
4981 return arg;
4982 else if (TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4983 return build_target_expr_with_type (arg, DECL_CONTEXT (fn));
4984 }
4985 else if (TREE_CODE (arg) == TARGET_EXPR
4986 || TYPE_HAS_TRIVIAL_INIT_REF (DECL_CONTEXT (fn)))
4987 {
4988 tree to = stabilize_reference
4989 (build_indirect_ref (TREE_VALUE (args), 0));
4990
4991 val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg);
4992 return val;
4993 }
4994 }
4995 else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR
4996 && copy_fn_p (fn)
4997 && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn)))
4998 {
4999 tree to = stabilize_reference
5000 (build_indirect_ref (TREE_VALUE (converted_args), 0));
5001 tree type = TREE_TYPE (to);
5002 tree as_base = CLASSTYPE_AS_BASE (type);
5003
5004 arg = TREE_VALUE (TREE_CHAIN (converted_args));
5005 if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base)))
5006 {
5007 arg = build_indirect_ref (arg, 0);
5008 val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg);
5009 }
5010 else
5011 {
5012 /* We must only copy the non-tail padding parts.
5013 Use __builtin_memcpy for the bitwise copy. */
5014
5015 tree args, t;
5016
5017 args = tree_cons (NULL, TYPE_SIZE_UNIT (as_base), NULL);
5018 args = tree_cons (NULL, arg, args);
5019 t = build_unary_op (ADDR_EXPR, to, 0);
5020 args = tree_cons (NULL, t, args);
5021 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
5022 t = build_call (t, args);
5023
5024 t = convert (TREE_TYPE (TREE_VALUE (args)), t);
5025 val = build_indirect_ref (t, 0);
5026 }
5027
5028 return val;
5029 }
5030
5031 mark_used (fn);
5032
5033 if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0)
5034 {
5035 tree t, *p = &TREE_VALUE (converted_args);
5036 tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (*p)),
5037 DECL_CONTEXT (fn),
5038 ba_any, NULL);
5039 gcc_assert (binfo && binfo != error_mark_node);
5040
5041 *p = build_base_path (PLUS_EXPR, *p, binfo, 1);
5042 if (TREE_SIDE_EFFECTS (*p))
5043 *p = save_expr (*p);
5044 t = build_pointer_type (TREE_TYPE (fn));
5045 if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn)))
5046 fn = build_java_interface_fn_ref (fn, *p);
5047 else
5048 fn = build_vfn_ref (*p, DECL_VINDEX (fn));
5049 TREE_TYPE (fn) = t;
5050 }
5051 else if (DECL_INLINE (fn))
5052 fn = inline_conversion (fn);
5053 else
5054 fn = build_addr_func (fn);
5055
5056 return build_cxx_call (fn, converted_args);
5057}
5058
5059/* Build and return a call to FN, using ARGS. This function performs
5060 no overload resolution, conversion, or other high-level
5061 operations. */
5062
5063tree
5064build_cxx_call (tree fn, tree args)
5065{
5066 tree fndecl;
5067
5068 fn = build_call (fn, args);
5069
5070 /* If this call might throw an exception, note that fact. */
5071 fndecl = get_callee_fndecl (fn);
5072 if ((!fndecl || !TREE_NOTHROW (fndecl))
5073 && at_function_scope_p ()
5074 && cfun)
5075 cp_function_chain->can_throw = 1;
5076
5077 /* Some built-in function calls will be evaluated at compile-time in
5078 fold (). */
5079 fn = fold_if_not_in_template (fn);
5080
5081 if (VOID_TYPE_P (TREE_TYPE (fn)))
5082 return fn;
5083
5084 fn = require_complete_type (fn);
5085 if (fn == error_mark_node)
5086 return error_mark_node;
5087
5088 if (IS_AGGR_TYPE (TREE_TYPE (fn)))
5089 fn = build_cplus_new (TREE_TYPE (fn), fn);
5090 return convert_from_reference (fn);
5091}
5092
5093static GTY(()) tree java_iface_lookup_fn;
5094
5095/* Make an expression which yields the address of the Java interface
5096 method FN. This is achieved by generating a call to libjava's
5097 _Jv_LookupInterfaceMethodIdx(). */
5098
5099static tree
5100build_java_interface_fn_ref (tree fn, tree instance)
5101{
5102 tree lookup_args, lookup_fn, method, idx;
5103 tree klass_ref, iface, iface_ref;
5104 int i;
5105
5106 if (!java_iface_lookup_fn)
5107 {
5108 tree endlink = build_void_list_node ();
5109 tree t = tree_cons (NULL_TREE, ptr_type_node,
5110 tree_cons (NULL_TREE, ptr_type_node,
5111 tree_cons (NULL_TREE, java_int_type_node,
5112 endlink)));
5113 java_iface_lookup_fn
5114 = builtin_function ("_Jv_LookupInterfaceMethodIdx",
5115 build_function_type (ptr_type_node, t),
5116 0, NOT_BUILT_IN, NULL, NULL_TREE);
5117 }
5118
5119 /* Look up the pointer to the runtime java.lang.Class object for `instance'.
5120 This is the first entry in the vtable. */
5121 klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
5122 integer_zero_node);
5123
5124 /* Get the java.lang.Class pointer for the interface being called. */
5125 iface = DECL_CONTEXT (fn);
5126 iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false);
5127 if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
5128 || DECL_CONTEXT (iface_ref) != iface)
5129 {
5130 error ("could not find class$ field in java interface type %qT",
5131 iface);
5132 return error_mark_node;
5133 }
5134 iface_ref = build_address (iface_ref);
5135 iface_ref = convert (build_pointer_type (iface), iface_ref);
5136
5137 /* Determine the itable index of FN. */
5138 i = 1;
5139 for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
5140 {
5141 if (!DECL_VIRTUAL_P (method))
5142 continue;
5143 if (fn == method)
5144 break;
5145 i++;
5146 }
5147 idx = build_int_cst (NULL_TREE, i);
5148
5149 lookup_args = tree_cons (NULL_TREE, klass_ref,
5150 tree_cons (NULL_TREE, iface_ref,
5151 build_tree_list (NULL_TREE, idx)));
5152 lookup_fn = build1 (ADDR_EXPR,
5153 build_pointer_type (TREE_TYPE (java_iface_lookup_fn)),
5154 java_iface_lookup_fn);
5155 return build3 (CALL_EXPR, ptr_type_node, lookup_fn, lookup_args, NULL_TREE);
5156}
5157
5158/* Returns the value to use for the in-charge parameter when making a
5159 call to a function with the indicated NAME.
5160
5161 FIXME:Can't we find a neater way to do this mapping? */
5162
5163tree
5164in_charge_arg_for_name (tree name)
5165{
5166 if (name == base_ctor_identifier
5167 || name == base_dtor_identifier)
5168 return integer_zero_node;
5169 else if (name == complete_ctor_identifier)
5170 return integer_one_node;
5171 else if (name == complete_dtor_identifier)
5172 return integer_two_node;
5173 else if (name == deleting_dtor_identifier)
5174 return integer_three_node;
5175
5176 /* This function should only be called with one of the names listed
5177 above. */
5178 gcc_unreachable ();
5179 return NULL_TREE;
5180}
5181
5182/* Build a call to a constructor, destructor, or an assignment
5183 operator for INSTANCE, an expression with class type. NAME
5184 indicates the special member function to call; ARGS are the
5185 arguments. BINFO indicates the base of INSTANCE that is to be
5186 passed as the `this' parameter to the member function called.
5187
5188 FLAGS are the LOOKUP_* flags to use when processing the call.
5189
5190 If NAME indicates a complete object constructor, INSTANCE may be
5191 NULL_TREE. In this case, the caller will call build_cplus_new to
5192 store the newly constructed object into a VAR_DECL. */
5193
5194tree
5195build_special_member_call (tree instance, tree name, tree args,
5196 tree binfo, int flags)
5197{
5198 tree fns;
5199 /* The type of the subobject to be constructed or destroyed. */
5200 tree class_type;
5201
5202 gcc_assert (name == complete_ctor_identifier
5203 || name == base_ctor_identifier
5204 || name == complete_dtor_identifier
5205 || name == base_dtor_identifier
5206 || name == deleting_dtor_identifier
5207 || name == ansi_assopname (NOP_EXPR));
5208 if (TYPE_P (binfo))
5209 {
5210 /* Resolve the name. */
5211 if (!complete_type_or_else (binfo, NULL_TREE))
5212 return error_mark_node;
5213
5214 binfo = TYPE_BINFO (binfo);
5215 }
5216
5217 gcc_assert (binfo != NULL_TREE);
5218
5219 class_type = BINFO_TYPE (binfo);
5220
5221 /* Handle the special case where INSTANCE is NULL_TREE. */
5222 if (name == complete_ctor_identifier && !instance)
5223 {
5224 instance = build_int_cst (build_pointer_type (class_type), 0);
5225 instance = build1 (INDIRECT_REF, class_type, instance);
5226 }
5227 else
5228 {
5229 if (name == complete_dtor_identifier
5230 || name == base_dtor_identifier
5231 || name == deleting_dtor_identifier)
5232 gcc_assert (args == NULL_TREE);
5233
5234 /* Convert to the base class, if necessary. */
5235 if (!same_type_ignoring_top_level_qualifiers_p
5236 (TREE_TYPE (instance), BINFO_TYPE (binfo)))
5237 {
5238 if (name != ansi_assopname (NOP_EXPR))
5239 /* For constructors and destructors, either the base is
5240 non-virtual, or it is virtual but we are doing the
5241 conversion from a constructor or destructor for the
5242 complete object. In either case, we can convert
5243 statically. */
5244 instance = convert_to_base_statically (instance, binfo);
5245 else
5246 /* However, for assignment operators, we must convert
5247 dynamically if the base is virtual. */
5248 instance = build_base_path (PLUS_EXPR, instance,
5249 binfo, /*nonnull=*/1);
5250 }
5251 }
5252
5253 gcc_assert (instance != NULL_TREE);
5254
5255 fns = lookup_fnfields (binfo, name, 1);
5256
5257 /* When making a call to a constructor or destructor for a subobject
5258 that uses virtual base classes, pass down a pointer to a VTT for
5259 the subobject. */
5260 if ((name == base_ctor_identifier
5261 || name == base_dtor_identifier)
5262 && CLASSTYPE_VBASECLASSES (class_type))
5263 {
5264 tree vtt;
5265 tree sub_vtt;
5266
5267 /* If the current function is a complete object constructor
5268 or destructor, then we fetch the VTT directly.
5269 Otherwise, we look it up using the VTT we were given. */
5270 vtt = TREE_CHAIN (CLASSTYPE_VTABLES (current_class_type));
5271 vtt = decay_conversion (vtt);
5272 vtt = build3 (COND_EXPR, TREE_TYPE (vtt),
5273 build2 (EQ_EXPR, boolean_type_node,
5274 current_in_charge_parm, integer_zero_node),
5275 current_vtt_parm,
5276 vtt);
5277 gcc_assert (BINFO_SUBVTT_INDEX (binfo));
5278 sub_vtt = build2 (PLUS_EXPR, TREE_TYPE (vtt), vtt,
5279 BINFO_SUBVTT_INDEX (binfo));
5280
5281 args = tree_cons (NULL_TREE, sub_vtt, args);
5282 }
5283
5284 return build_new_method_call (instance, fns, args,
5285 TYPE_BINFO (BINFO_TYPE (binfo)),
5286 flags, /*fn=*/NULL);
5287}
5288
5289/* Return the NAME, as a C string. The NAME indicates a function that
5290 is a member of TYPE. *FREE_P is set to true if the caller must
5291 free the memory returned.
5292
5293 Rather than go through all of this, we should simply set the names
5294 of constructors and destructors appropriately, and dispense with
5295 ctor_identifier, dtor_identifier, etc. */
5296
5297static char *
5298name_as_c_string (tree name, tree type, bool *free_p)
5299{
5300 char *pretty_name;
5301
5302 /* Assume that we will not allocate memory. */
5303 *free_p = false;
5304 /* Constructors and destructors are special. */
5305 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5306 {
5307 pretty_name
5308 = (char *) IDENTIFIER_POINTER (constructor_name (type));
5309 /* For a destructor, add the '~'. */
5310 if (name == complete_dtor_identifier
5311 || name == base_dtor_identifier
5312 || name == deleting_dtor_identifier)
5313 {
5314 pretty_name = concat ("~", pretty_name, NULL);
5315 /* Remember that we need to free the memory allocated. */
5316 *free_p = true;
5317 }
5318 }
5319 else if (IDENTIFIER_TYPENAME_P (name))
5320 {
5321 pretty_name = concat ("operator ",
5322 type_as_string (TREE_TYPE (name),
5323 TFF_PLAIN_IDENTIFIER),
5324 NULL);
5325 /* Remember that we need to free the memory allocated. */
5326 *free_p = true;
5327 }
5328 else
5329 pretty_name = (char *) IDENTIFIER_POINTER (name);
5330
5331 return pretty_name;
5332}
5333
5334/* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will
5335 be set, upon return, to the function called. */
5336
5337tree
5338build_new_method_call (tree instance, tree fns, tree args,
5339 tree conversion_path, int flags,
5340 tree *fn_p)
5341{
5342 struct z_candidate *candidates = 0, *cand;
5343 tree explicit_targs = NULL_TREE;
5344 tree basetype = NULL_TREE;
5345 tree access_binfo;
5346 tree optype;
5347 tree mem_args = NULL_TREE, instance_ptr;
5348 tree name;
5349 tree user_args;
5350 tree call;
5351 tree fn;
5352 tree class_type;
5353 int template_only = 0;
5354 bool any_viable_p;
5355 tree orig_instance;
5356 tree orig_fns;
5357 tree orig_args;
5358 void *p;
5359
5360 gcc_assert (instance != NULL_TREE);
5361
5362 /* We don't know what function we're going to call, yet. */
5363 if (fn_p)
5364 *fn_p = NULL_TREE;
5365
5366 if (error_operand_p (instance)
5367 || error_operand_p (fns)
5368 || args == error_mark_node)
5369 return error_mark_node;
5370
5371 if (!BASELINK_P (fns))
5372 {
5373 error ("call to non-function %qD", fns);
5374 return error_mark_node;
5375 }
5376
5377 orig_instance = instance;
5378 orig_fns = fns;
5379 orig_args = args;
5380
5381 /* Dismantle the baselink to collect all the information we need. */
5382 if (!conversion_path)
5383 conversion_path = BASELINK_BINFO (fns);
5384 access_binfo = BASELINK_ACCESS_BINFO (fns);
5385 optype = BASELINK_OPTYPE (fns);
5386 fns = BASELINK_FUNCTIONS (fns);
5387 if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
5388 {
5389 explicit_targs = TREE_OPERAND (fns, 1);
5390 fns = TREE_OPERAND (fns, 0);
5391 template_only = 1;
5392 }
5393 gcc_assert (TREE_CODE (fns) == FUNCTION_DECL
5394 || TREE_CODE (fns) == TEMPLATE_DECL
5395 || TREE_CODE (fns) == OVERLOAD);
5396 fn = get_first_fn (fns);
5397 name = DECL_NAME (fn);
5398
5399 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance));
5400 gcc_assert (CLASS_TYPE_P (basetype));
5401
5402 if (processing_template_decl)
5403 {
5404 instance = build_non_dependent_expr (instance);
5405 args = build_non_dependent_args (orig_args);
5406 }
5407
5408 /* The USER_ARGS are the arguments we will display to users if an
5409 error occurs. The USER_ARGS should not include any
5410 compiler-generated arguments. The "this" pointer hasn't been
5411 added yet. However, we must remove the VTT pointer if this is a
5412 call to a base-class constructor or destructor. */
5413 user_args = args;
5414 if (IDENTIFIER_CTOR_OR_DTOR_P (name))
5415 {
5416 /* Callers should explicitly indicate whether they want to construct
5417 the complete object or just the part without virtual bases. */
5418 gcc_assert (name != ctor_identifier);
5419 /* Similarly for destructors. */
5420 gcc_assert (name != dtor_identifier);
5421 /* Remove the VTT pointer, if present. */
5422 if ((name == base_ctor_identifier || name == base_dtor_identifier)
5423 && CLASSTYPE_VBASECLASSES (basetype))
5424 user_args = TREE_CHAIN (user_args);
5425 }
5426
5427 /* Process the argument list. */
5428 args = resolve_args (args);
5429 if (args == error_mark_node)
5430 return error_mark_node;
5431
5432 instance_ptr = build_this (instance);
5433
5434 /* It's OK to call destructors on cv-qualified objects. Therefore,
5435 convert the INSTANCE_PTR to the unqualified type, if necessary. */
5436 if (DECL_DESTRUCTOR_P (fn))
5437 {
5438 tree type = build_pointer_type (basetype);
5439 if (!same_type_p (type, TREE_TYPE (instance_ptr)))
5440 instance_ptr = build_nop (type, instance_ptr);
5441 name = complete_dtor_identifier;
5442 }
5443
5444 class_type = (conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE);
5445 mem_args = tree_cons (NULL_TREE, instance_ptr, args);
5446
5447 /* Get the high-water mark for the CONVERSION_OBSTACK. */
5448 p = conversion_obstack_alloc (0);
5449
5450 for (fn = fns; fn; fn = OVL_NEXT (fn))
5451 {
5452 tree t = OVL_CURRENT (fn);
5453 tree this_arglist;
5454
5455 /* We can end up here for copy-init of same or base class. */
5456 if ((flags & LOOKUP_ONLYCONVERTING)
5457 && DECL_NONCONVERTING_P (t))
5458 continue;
5459
5460 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (t))
5461 this_arglist = mem_args;
5462 else
5463 this_arglist = args;
5464
5465 if (TREE_CODE (t) == TEMPLATE_DECL)
5466 /* A member template. */
5467 add_template_candidate (&candidates, t,
5468 class_type,
5469 explicit_targs,
5470 this_arglist, optype,
5471 access_binfo,
5472 conversion_path,
5473 flags,
5474 DEDUCE_CALL);
5475 else if (! template_only)
5476 add_function_candidate (&candidates, t,
5477 class_type,
5478 this_arglist,
5479 access_binfo,
5480 conversion_path,
5481 flags);
5482 }
5483
5484 candidates = splice_viable (candidates, pedantic, &any_viable_p);
5485 if (!any_viable_p)
5486 {
5487 if (!COMPLETE_TYPE_P (basetype))
5488 cxx_incomplete_type_error (instance_ptr, basetype);
5489 else
5490 {
5491 char *pretty_name;
5492 bool free_p;
5493
5494 pretty_name = name_as_c_string (name, basetype, &free_p);
5495 error ("no matching function for call to %<%T::%s(%A)%#V%>",
5496 basetype, pretty_name, user_args,
5497 TREE_TYPE (TREE_TYPE (instance_ptr)));
5498 if (free_p)
5499 free (pretty_name);
5500 }
5501 print_z_candidates (candidates);
5502 call = error_mark_node;
5503 }
5504 else
5505 {
5506 cand = tourney (candidates);
5507 if (cand == 0)
5508 {
5509 char *pretty_name;
5510 bool free_p;
5511
5512 pretty_name = name_as_c_string (name, basetype, &free_p);
5513 error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name,
5514 user_args);
5515 print_z_candidates (candidates);
5516 if (free_p)
5517 free (pretty_name);
5518 call = error_mark_node;
5519 }
5520 else
5521 {
5522 fn = cand->fn;
5523
5524 if (!(flags & LOOKUP_NONVIRTUAL)
5525 && DECL_PURE_VIRTUAL_P (fn)
5526 && instance == current_class_ref
5527 && (DECL_CONSTRUCTOR_P (current_function_decl)
5528 || DECL_DESTRUCTOR_P (current_function_decl)))
5529 /* This is not an error, it is runtime undefined
5530 behavior. */
5531 warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ?
5532 "abstract virtual %q#D called from constructor"
5533 : "abstract virtual %q#D called from destructor"),
5534 fn);
5535
5536 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
5537 && is_dummy_object (instance_ptr))
5538 {
5539 error ("cannot call member function %qD without object",
5540 fn);
5541 call = error_mark_node;
5542 }
5543 else
5544 {
5545 if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
5546 && resolves_to_fixed_type_p (instance, 0))
5547 flags |= LOOKUP_NONVIRTUAL;
5548 /* Now we know what function is being called. */
5549 if (fn_p)
5550 *fn_p = fn;
5551 /* Build the actual CALL_EXPR. */
5552 call = build_over_call (cand, flags);
5553 /* In an expression of the form `a->f()' where `f' turns
5554 out to be a static member function, `a' is
5555 none-the-less evaluated. */
5556 if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
5557 && !is_dummy_object (instance_ptr)
5558 && TREE_SIDE_EFFECTS (instance_ptr))
5559 call = build2 (COMPOUND_EXPR, TREE_TYPE (call),
5560 instance_ptr, call);
5561 else if (call != error_mark_node
5562 && DECL_DESTRUCTOR_P (cand->fn)
5563 && !VOID_TYPE_P (TREE_TYPE (call)))
5564 /* An explicit call of the form "x->~X()" has type
5565 "void". However, on platforms where destructors
5566 return "this" (i.e., those where
5567 targetm.cxx.cdtor_returns_this is true), such calls
5568 will appear to have a return value of pointer type
5569 to the low-level call machinery. We do not want to
5570 change the low-level machinery, since we want to be
5571 able to optimize "delete f()" on such platforms as
5572 "operator delete(~X(f()))" (rather than generating
5573 "t = f(), ~X(t), operator delete (t)"). */
5574 call = build_nop (void_type_node, call);
5575 }
5576 }
5577 }
5578
5579 if (processing_template_decl && call != error_mark_node)
5580 call = (build_min_non_dep
5581 (CALL_EXPR, call,
5582 build_min_nt (COMPONENT_REF, orig_instance, orig_fns, NULL_TREE),
5583 orig_args, NULL_TREE));
5584
5585 /* Free all the conversions we allocated. */
5586 obstack_free (&conversion_obstack, p);
5587
5588 return call;
5589}
5590
5591/* Returns true iff standard conversion sequence ICS1 is a proper
5592 subsequence of ICS2. */
5593
5594static bool
5595is_subseq (conversion *ics1, conversion *ics2)
5596{
5597 /* We can assume that a conversion of the same code
5598 between the same types indicates a subsequence since we only get
5599 here if the types we are converting from are the same. */
5600
5601 while (ics1->kind == ck_rvalue
5602 || ics1->kind == ck_lvalue)
5603 ics1 = ics1->u.next;
5604
5605 while (1)
5606 {
5607 while (ics2->kind == ck_rvalue
5608 || ics2->kind == ck_lvalue)
5609 ics2 = ics2->u.next;
5610
5611 if (ics2->kind == ck_user
5612 || ics2->kind == ck_ambig
5613 || ics2->kind == ck_identity)
5614 /* At this point, ICS1 cannot be a proper subsequence of
5615 ICS2. We can get a USER_CONV when we are comparing the
5616 second standard conversion sequence of two user conversion
5617 sequences. */
5618 return false;
5619
5620 ics2 = ics2->u.next;
5621
5622 if (ics2->kind == ics1->kind
5623 && same_type_p (ics2->type, ics1->type)
5624 && same_type_p (ics2->u.next->type,
5625 ics1->u.next->type))
5626 return true;
5627 }
5628}
5629
5630/* Returns nonzero iff DERIVED is derived from BASE. The inputs may
5631 be any _TYPE nodes. */
5632
5633bool
5634is_properly_derived_from (tree derived, tree base)
5635{
5636 if (!IS_AGGR_TYPE_CODE (TREE_CODE (derived))
5637 || !IS_AGGR_TYPE_CODE (TREE_CODE (base)))
5638 return false;
5639
5640 /* We only allow proper derivation here. The DERIVED_FROM_P macro
5641 considers every class derived from itself. */
5642 return (!same_type_ignoring_top_level_qualifiers_p (derived, base)
5643 && DERIVED_FROM_P (base, derived));
5644}
5645
5646/* We build the ICS for an implicit object parameter as a pointer
5647 conversion sequence. However, such a sequence should be compared
5648 as if it were a reference conversion sequence. If ICS is the
5649 implicit conversion sequence for an implicit object parameter,
5650 modify it accordingly. */
5651
5652static void
5653maybe_handle_implicit_object (conversion **ics)
5654{
5655 if ((*ics)->this_p)
5656 {
5657 /* [over.match.funcs]
5658
5659 For non-static member functions, the type of the
5660 implicit object parameter is "reference to cv X"
5661 where X is the class of which the function is a
5662 member and cv is the cv-qualification on the member
5663 function declaration. */
5664 conversion *t = *ics;
5665 tree reference_type;
5666
5667 /* The `this' parameter is a pointer to a class type. Make the
5668 implicit conversion talk about a reference to that same class
5669 type. */
5670 reference_type = TREE_TYPE (t->type);
5671 reference_type = build_reference_type (reference_type);
5672
5673 if (t->kind == ck_qual)
5674 t = t->u.next;
5675 if (t->kind == ck_ptr)
5676 t = t->u.next;
5677 t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
5678 t = direct_reference_binding (reference_type, t);
5679 *ics = t;
5680 }
5681}
5682
5683/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
5684 and return the type to which the reference refers. Otherwise,
5685 leave *ICS unchanged and return NULL_TREE. */
5686
5687static tree
5688maybe_handle_ref_bind (conversion **ics)
5689{
5690 if ((*ics)->kind == ck_ref_bind)
5691 {
5692 conversion *old_ics = *ics;
5693 tree type = TREE_TYPE (old_ics->type);
5694 *ics = old_ics->u.next;
5695 (*ics)->user_conv_p = old_ics->user_conv_p;
5696 (*ics)->bad_p = old_ics->bad_p;
5697 return type;
5698 }
5699
5700 return NULL_TREE;
5701}
5702
5703/* Compare two implicit conversion sequences according to the rules set out in
5704 [over.ics.rank]. Return values:
5705
5706 1: ics1 is better than ics2
5707 -1: ics2 is better than ics1
5708 0: ics1 and ics2 are indistinguishable */
5709
5710static int
5711compare_ics (conversion *ics1, conversion *ics2)
5712{
5713 tree from_type1;
5714 tree from_type2;
5715 tree to_type1;
5716 tree to_type2;
5717 tree deref_from_type1 = NULL_TREE;
5718 tree deref_from_type2 = NULL_TREE;
5719 tree deref_to_type1 = NULL_TREE;
5720 tree deref_to_type2 = NULL_TREE;
5721 conversion_rank rank1, rank2;
5722
5723 /* REF_BINDING is nonzero if the result of the conversion sequence
5724 is a reference type. In that case TARGET_TYPE is the
5725 type referred to by the reference. */
5726 tree target_type1;
5727 tree target_type2;
5728
5729 /* Handle implicit object parameters. */
5730 maybe_handle_implicit_object (&ics1);
5731 maybe_handle_implicit_object (&ics2);
5732
5733 /* Handle reference parameters. */
5734 target_type1 = maybe_handle_ref_bind (&ics1);
5735 target_type2 = maybe_handle_ref_bind (&ics2);
5736
5737 /* [over.ics.rank]
5738
5739 When comparing the basic forms of implicit conversion sequences (as
5740 defined in _over.best.ics_)
5741
5742 --a standard conversion sequence (_over.ics.scs_) is a better
5743 conversion sequence than a user-defined conversion sequence
5744 or an ellipsis conversion sequence, and
5745
5746 --a user-defined conversion sequence (_over.ics.user_) is a
5747 better conversion sequence than an ellipsis conversion sequence
5748 (_over.ics.ellipsis_). */
5749 rank1 = CONVERSION_RANK (ics1);
5750 rank2 = CONVERSION_RANK (ics2);
5751
5752 if (rank1 > rank2)
5753 return -1;
5754 else if (rank1 < rank2)
5755 return 1;
5756
5757 if (rank1 == cr_bad)
5758 {
5759 /* XXX Isn't this an extension? */
5760 /* Both ICS are bad. We try to make a decision based on what
5761 would have happened if they'd been good. */
5762 if (ics1->user_conv_p > ics2->user_conv_p
5763 || ics1->rank > ics2->rank)
5764 return -1;
5765 else if (ics1->user_conv_p < ics2->user_conv_p
5766 || ics1->rank < ics2->rank)
5767 return 1;
5768
5769 /* We couldn't make up our minds; try to figure it out below. */
5770 }
5771
5772 if (ics1->ellipsis_p)
5773 /* Both conversions are ellipsis conversions. */
5774 return 0;
5775
5776 /* User-defined conversion sequence U1 is a better conversion sequence
5777 than another user-defined conversion sequence U2 if they contain the
5778 same user-defined conversion operator or constructor and if the sec-
5779 ond standard conversion sequence of U1 is better than the second
5780 standard conversion sequence of U2. */
5781
5782 if (ics1->user_conv_p)
5783 {
5784 conversion *t1;
5785 conversion *t2;
5786
5787 for (t1 = ics1; t1->kind != ck_user; t1 = t1->u.next)
5788 if (t1->kind == ck_ambig)
5789 return 0;
5790 for (t2 = ics2; t2->kind != ck_user; t2 = t2->u.next)
5791 if (t2->kind == ck_ambig)
5792 return 0;
5793
5794 if (t1->cand->fn != t2->cand->fn)
5795 return 0;
5796
5797 /* We can just fall through here, after setting up
5798 FROM_TYPE1 and FROM_TYPE2. */
5799 from_type1 = t1->type;
5800 from_type2 = t2->type;
5801 }
5802 else
5803 {
5804 conversion *t1;
5805 conversion *t2;
5806
5807 /* We're dealing with two standard conversion sequences.
5808
5809 [over.ics.rank]
5810
5811 Standard conversion sequence S1 is a better conversion
5812 sequence than standard conversion sequence S2 if
5813
5814 --S1 is a proper subsequence of S2 (comparing the conversion
5815 sequences in the canonical form defined by _over.ics.scs_,
5816 excluding any Lvalue Transformation; the identity
5817 conversion sequence is considered to be a subsequence of
5818 any non-identity conversion sequence */
5819
5820 t1 = ics1;
5821 while (t1->kind != ck_identity)
5822 t1 = t1->u.next;
5823 from_type1 = t1->type;
5824
5825 t2 = ics2;
5826 while (t2->kind != ck_identity)
5827 t2 = t2->u.next;
5828 from_type2 = t2->type;
5829 }
5830
5831 if (same_type_p (from_type1, from_type2))
5832 {
5833 if (is_subseq (ics1, ics2))
5834 return 1;
5835 if (is_subseq (ics2, ics1))
5836 return -1;
5837 }
5838 /* Otherwise, one sequence cannot be a subsequence of the other; they
5839 don't start with the same type. This can happen when comparing the
5840 second standard conversion sequence in two user-defined conversion
5841 sequences. */
5842
5843 /* [over.ics.rank]
5844
5845 Or, if not that,
5846
5847 --the rank of S1 is better than the rank of S2 (by the rules
5848 defined below):
5849
5850 Standard conversion sequences are ordered by their ranks: an Exact
5851 Match is a better conversion than a Promotion, which is a better
5852 conversion than a Conversion.
5853
5854 Two conversion sequences with the same rank are indistinguishable
5855 unless one of the following rules applies:
5856
5857 --A conversion that is not a conversion of a pointer, or pointer
5858 to member, to bool is better than another conversion that is such
5859 a conversion.
5860
5861 The ICS_STD_RANK automatically handles the pointer-to-bool rule,
5862 so that we do not have to check it explicitly. */
5863 if (ics1->rank < ics2->rank)
5864 return 1;
5865 else if (ics2->rank < ics1->rank)
5866 return -1;
5867
5868 to_type1 = ics1->type;
5869 to_type2 = ics2->type;
5870
5871 if (TYPE_PTR_P (from_type1)
5872 && TYPE_PTR_P (from_type2)
5873 && TYPE_PTR_P (to_type1)
5874 && TYPE_PTR_P (to_type2))
5875 {
5876 deref_from_type1 = TREE_TYPE (from_type1);
5877 deref_from_type2 = TREE_TYPE (from_type2);
5878 deref_to_type1 = TREE_TYPE (to_type1);
5879 deref_to_type2 = TREE_TYPE (to_type2);
5880 }
5881 /* The rules for pointers to members A::* are just like the rules
5882 for pointers A*, except opposite: if B is derived from A then
5883 A::* converts to B::*, not vice versa. For that reason, we
5884 switch the from_ and to_ variables here. */
5885 else if ((TYPE_PTRMEM_P (from_type1) && TYPE_PTRMEM_P (from_type2)
5886 && TYPE_PTRMEM_P (to_type1) && TYPE_PTRMEM_P (to_type2))
5887 || (TYPE_PTRMEMFUNC_P (from_type1)
5888 && TYPE_PTRMEMFUNC_P (from_type2)
5889 && TYPE_PTRMEMFUNC_P (to_type1)
5890 && TYPE_PTRMEMFUNC_P (to_type2)))
5891 {
5892 deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1);
5893 deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2);
5894 deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1);
5895 deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2);
5896 }
5897
5898 if (deref_from_type1 != NULL_TREE
5899 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type1))
5900 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_from_type2)))
5901 {
5902 /* This was one of the pointer or pointer-like conversions.
5903
5904 [over.ics.rank]
5905
5906 --If class B is derived directly or indirectly from class A,
5907 conversion of B* to A* is better than conversion of B* to
5908 void*, and conversion of A* to void* is better than
5909 conversion of B* to void*. */
5910 if (TREE_CODE (deref_to_type1) == VOID_TYPE
5911 && TREE_CODE (deref_to_type2) == VOID_TYPE)
5912 {
5913 if (is_properly_derived_from (deref_from_type1,
5914 deref_from_type2))
5915 return -1;
5916 else if (is_properly_derived_from (deref_from_type2,
5917 deref_from_type1))
5918 return 1;
5919 }
5920 else if (TREE_CODE (deref_to_type1) == VOID_TYPE
5921 || TREE_CODE (deref_to_type2) == VOID_TYPE)
5922 {
5923 if (same_type_p (deref_from_type1, deref_from_type2))
5924 {
5925 if (TREE_CODE (deref_to_type2) == VOID_TYPE)
5926 {
5927 if (is_properly_derived_from (deref_from_type1,
5928 deref_to_type1))
5929 return 1;
5930 }
5931 /* We know that DEREF_TO_TYPE1 is `void' here. */
5932 else if (is_properly_derived_from (deref_from_type1,
5933 deref_to_type2))
5934 return -1;
5935 }
5936 }
5937 else if (IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type1))
5938 && IS_AGGR_TYPE_CODE (TREE_CODE (deref_to_type2)))
5939 {
5940 /* [over.ics.rank]
5941
5942 --If class B is derived directly or indirectly from class A
5943 and class C is derived directly or indirectly from B,
5944
5945 --conversion of C* to B* is better than conversion of C* to
5946 A*,
5947
5948 --conversion of B* to A* is better than conversion of C* to
5949 A* */
5950 if (same_type_p (deref_from_type1, deref_from_type2))
5951 {
5952 if (is_properly_derived_from (deref_to_type1,
5953 deref_to_type2))
5954 return 1;
5955 else if (is_properly_derived_from (deref_to_type2,
5956 deref_to_type1))
5957 return -1;
5958 }
5959 else if (same_type_p (deref_to_type1, deref_to_type2))
5960 {
5961 if (is_properly_derived_from (deref_from_type2,
5962 deref_from_type1))
5963 return 1;
5964 else if (is_properly_derived_from (deref_from_type1,
5965 deref_from_type2))
5966 return -1;
5967 }
5968 }
5969 }
5970 else if (CLASS_TYPE_P (non_reference (from_type1))
5971 && same_type_p (from_type1, from_type2))
5972 {
5973 tree from = non_reference (from_type1);
5974
5975 /* [over.ics.rank]
5976
5977 --binding of an expression of type C to a reference of type
5978 B& is better than binding an expression of type C to a
5979 reference of type A&
5980
5981 --conversion of C to B is better than conversion of C to A, */
5982 if (is_properly_derived_from (from, to_type1)
5983 && is_properly_derived_from (from, to_type2))
5984 {
5985 if (is_properly_derived_from (to_type1, to_type2))
5986 return 1;
5987 else if (is_properly_derived_from (to_type2, to_type1))
5988 return -1;
5989 }
5990 }
5991 else if (CLASS_TYPE_P (non_reference (to_type1))
5992 && same_type_p (to_type1, to_type2))
5993 {
5994 tree to = non_reference (to_type1);
5995
5996 /* [over.ics.rank]
5997
5998 --binding of an expression of type B to a reference of type
5999 A& is better than binding an expression of type C to a
6000 reference of type A&,
6001
6002 --conversion of B to A is better than conversion of C to A */
6003 if (is_properly_derived_from (from_type1, to)
6004 && is_properly_derived_from (from_type2, to))
6005 {
6006 if (is_properly_derived_from (from_type2, from_type1))
6007 return 1;
6008 else if (is_properly_derived_from (from_type1, from_type2))
6009 return -1;
6010 }
6011 }
6012
6013 /* [over.ics.rank]
6014
6015 --S1 and S2 differ only in their qualification conversion and yield
6016 similar types T1 and T2 (_conv.qual_), respectively, and the cv-
6017 qualification signature of type T1 is a proper subset of the cv-
6018 qualification signature of type T2 */
6019 if (ics1->kind == ck_qual
6020 && ics2->kind == ck_qual
6021 && same_type_p (from_type1, from_type2))
6022 return comp_cv_qual_signature (to_type1, to_type2);
6023
6024 /* [over.ics.rank]
6025
6026 --S1 and S2 are reference bindings (_dcl.init.ref_), and the
6027 types to which the references refer are the same type except for
6028 top-level cv-qualifiers, and the type to which the reference
6029 initialized by S2 refers is more cv-qualified than the type to
6030 which the reference initialized by S1 refers */
6031
6032 if (target_type1 && target_type2
6033 && same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
6034 return comp_cv_qualification (target_type2, target_type1);
6035
6036 /* Neither conversion sequence is better than the other. */
6037 return 0;
6038}
6039
6040/* The source type for this standard conversion sequence. */
6041
6042static tree
6043source_type (conversion *t)
6044{
6045 for (;; t = t->u.next)
6046 {
6047 if (t->kind == ck_user
6048 || t->kind == ck_ambig
6049 || t->kind == ck_identity)
6050 return t->type;
6051 }
6052 gcc_unreachable ();
6053}
6054
6055/* Note a warning about preferring WINNER to LOSER. We do this by storing
6056 a pointer to LOSER and re-running joust to produce the warning if WINNER
6057 is actually used. */
6058
6059static void
6060add_warning (struct z_candidate *winner, struct z_candidate *loser)
6061{
6062 candidate_warning *cw = (candidate_warning *)
6063 conversion_obstack_alloc (sizeof (candidate_warning));
6064 cw->loser = loser;
6065 cw->next = winner->warnings;
6066 winner->warnings = cw;
6067}
6068
6069/* Compare two candidates for overloading as described in
6070 [over.match.best]. Return values:
6071
6072 1: cand1 is better than cand2
6073 -1: cand2 is better than cand1
6074 0: cand1 and cand2 are indistinguishable */
6075
6076static int
6077joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn)
6078{
6079 int winner = 0;
6080 int off1 = 0, off2 = 0;
6081 size_t i;
6082 size_t len;
6083
6084 /* Candidates that involve bad conversions are always worse than those
6085 that don't. */
6086 if (cand1->viable > cand2->viable)
6087 return 1;
6088 if (cand1->viable < cand2->viable)
6089 return -1;
6090
6091 /* If we have two pseudo-candidates for conversions to the same type,
6092 or two candidates for the same function, arbitrarily pick one. */
6093 if (cand1->fn == cand2->fn
6094 && (IS_TYPE_OR_DECL_P (cand1->fn)))
6095 return 1;
6096
6097 /* a viable function F1
6098 is defined to be a better function than another viable function F2 if
6099 for all arguments i, ICSi(F1) is not a worse conversion sequence than
6100 ICSi(F2), and then */
6101
6102 /* for some argument j, ICSj(F1) is a better conversion sequence than
6103 ICSj(F2) */
6104
6105 /* For comparing static and non-static member functions, we ignore
6106 the implicit object parameter of the non-static function. The
6107 standard says to pretend that the static function has an object
6108 parm, but that won't work with operator overloading. */
6109 len = cand1->num_convs;
6110 if (len != cand2->num_convs)
6111 {
6112 int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn);
6113 int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn);
6114
6115 gcc_assert (static_1 != static_2);
6116
6117 if (static_1)
6118 off2 = 1;
6119 else
6120 {
6121 off1 = 1;
6122 --len;
6123 }
6124 }
6125
6126 for (i = 0; i < len; ++i)
6127 {
6128 conversion *t1 = cand1->convs[i + off1];
6129 conversion *t2 = cand2->convs[i + off2];
6130 int comp = compare_ics (t1, t2);
6131
6132 if (comp != 0)
6133 {
6134 if (warn_sign_promo
6135 && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2)
6136 == cr_std + cr_promotion)
6137 && t1->kind == ck_std
6138 && t2->kind == ck_std
6139 && TREE_CODE (t1->type) == INTEGER_TYPE
6140 && TREE_CODE (t2->type) == INTEGER_TYPE
6141 && (TYPE_PRECISION (t1->type)
6142 == TYPE_PRECISION (t2->type))
6143 && (TYPE_UNSIGNED (t1->u.next->type)
6144 || (TREE_CODE (t1->u.next->type)
6145 == ENUMERAL_TYPE)))
6146 {
6147 tree type = t1->u.next->type;
6148 tree type1, type2;
6149 struct z_candidate *w, *l;
6150 if (comp > 0)
6151 type1 = t1->type, type2 = t2->type,
6152 w = cand1, l = cand2;
6153 else
6154 type1 = t2->type, type2 = t1->type,
6155 w = cand2, l = cand1;
6156
6157 if (warn)
6158 {
6159 warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT",
6160 type, type1, type2);
6161 warning (OPT_Wsign_promo, " in call to %qD", w->fn);
6162 }
6163 else
6164 add_warning (w, l);
6165 }
6166
6167 if (winner && comp != winner)
6168 {
6169 winner = 0;
6170 goto tweak;
6171 }
6172 winner = comp;
6173 }
6174 }
6175
6176 /* warn about confusing overload resolution for user-defined conversions,
6177 either between a constructor and a conversion op, or between two
6178 conversion ops. */
6179 if (winner && warn_conversion && cand1->second_conv
6180 && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn))
6181 && winner != compare_ics (cand1->second_conv, cand2->second_conv))
6182 {
6183 struct z_candidate *w, *l;
6184 bool give_warning = false;
6185
6186 if (winner == 1)
6187 w = cand1, l = cand2;
6188 else
6189 w = cand2, l = cand1;
6190
6191 /* We don't want to complain about `X::operator T1 ()'
6192 beating `X::operator T2 () const', when T2 is a no less
6193 cv-qualified version of T1. */
6194 if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn)
6195 && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn))
6196 {
6197 tree t = TREE_TYPE (TREE_TYPE (l->fn));
6198 tree f = TREE_TYPE (TREE_TYPE (w->fn));
6199
6200 if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t))
6201 {
6202 t = TREE_TYPE (t);
6203 f = TREE_TYPE (f);
6204 }
6205 if (!comp_ptr_ttypes (t, f))
6206 give_warning = true;
6207 }
6208 else
6209 give_warning = true;
6210
6211 if (!give_warning)
6212 /*NOP*/;
6213 else if (warn)
6214 {
6215 tree source = source_type (w->convs[0]);
6216 if (! DECL_CONSTRUCTOR_P (w->fn))
6217 source = TREE_TYPE (source);
6218 warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn);
6219 warning (OPT_Wconversion, " for conversion from %qT to %qT",
6220 source, w->second_conv->type);
6221 inform (" because conversion sequence for the argument is better");
6222 }
6223 else
6224 add_warning (w, l);
6225 }
6226
6227 if (winner)
6228 return winner;
6229
6230 /* or, if not that,
6231 F1 is a non-template function and F2 is a template function
6232 specialization. */
6233
6234 if (!cand1->template_decl && cand2->template_decl)
6235 return 1;
6236 else if (cand1->template_decl && !cand2->template_decl)
6237 return -1;
6238
6239 /* or, if not that,
6240 F1 and F2 are template functions and the function template for F1 is
6241 more specialized than the template for F2 according to the partial
6242 ordering rules. */
6243
6244 if (cand1->template_decl && cand2->template_decl)
6245 {
6246 winner = more_specialized_fn
6247 (TI_TEMPLATE (cand1->template_decl),
6248 TI_TEMPLATE (cand2->template_decl),
6249 /* [temp.func.order]: The presence of unused ellipsis and default
6250 arguments has no effect on the partial ordering of function
6251 templates. add_function_candidate() will not have
6252 counted the "this" argument for constructors. */
6253 cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn));
6254 if (winner)
6255 return winner;
6256 }
6257
6258 /* or, if not that,
6259 the context is an initialization by user-defined conversion (see
6260 _dcl.init_ and _over.match.user_) and the standard conversion
6261 sequence from the return type of F1 to the destination type (i.e.,
6262 the type of the entity being initialized) is a better conversion
6263 sequence than the standard conversion sequence from the return type
6264 of F2 to the destination type. */
6265
6266 if (cand1->second_conv)
6267 {
6268 winner = compare_ics (cand1->second_conv, cand2->second_conv);
6269 if (winner)
6270 return winner;
6271 }
6272
6273 /* Check whether we can discard a builtin candidate, either because we
6274 have two identical ones or matching builtin and non-builtin candidates.
6275
6276 (Pedantically in the latter case the builtin which matched the user
6277 function should not be added to the overload set, but we spot it here.
6278
6279 [over.match.oper]
6280 ... the builtin candidates include ...
6281 - do not have the same parameter type list as any non-template
6282 non-member candidate. */
6283
6284 if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE
6285 || TREE_CODE (cand2->fn) == IDENTIFIER_NODE)
6286 {
6287 for (i = 0; i < len; ++i)
6288 if (!same_type_p (cand1->convs[i]->type,
6289 cand2->convs[i]->type))
6290 break;
6291 if (i == cand1->num_convs)
6292 {
6293 if (cand1->fn == cand2->fn)
6294 /* Two built-in candidates; arbitrarily pick one. */
6295 return 1;
6296 else if (TREE_CODE (cand1->fn) == IDENTIFIER_NODE)
6297 /* cand1 is built-in; prefer cand2. */
6298 return -1;
6299 else
6300 /* cand2 is built-in; prefer cand1. */
6301 return 1;
6302 }
6303 }
6304
6305 /* If the two functions are the same (this can happen with declarations
6306 in multiple scopes and arg-dependent lookup), arbitrarily choose one. */
6307 if (DECL_P (cand1->fn) && DECL_P (cand2->fn)
6308 && equal_functions (cand1->fn, cand2->fn))
6309 return 1;
6310
6311tweak:
6312
6313 /* Extension: If the worst conversion for one candidate is worse than the
6314 worst conversion for the other, take the first. */
6315 if (!pedantic)
6316 {
6317 conversion_rank rank1 = cr_identity, rank2 = cr_identity;
6318 struct z_candidate *w = 0, *l = 0;
6319
6320 for (i = 0; i < len; ++i)
6321 {
6322 if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1)
6323 rank1 = CONVERSION_RANK (cand1->convs[i+off1]);
6324 if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2)
6325 rank2 = CONVERSION_RANK (cand2->convs[i + off2]);
6326 }
6327 if (rank1 < rank2)
6328 winner = 1, w = cand1, l = cand2;
6329 if (rank1 > rank2)
6330 winner = -1, w = cand2, l = cand1;
6331 if (winner)
6332 {
6333 if (warn)
6334 {
6335 pedwarn ("\
6336ISO C++ says that these are ambiguous, even \
6337though the worst conversion for the first is better than \
6338the worst conversion for the second:");
6339 print_z_candidate (_("candidate 1:"), w);
6340 print_z_candidate (_("candidate 2:"), l);
6341 }
6342 else
6343 add_warning (w, l);
6344 return winner;
6345 }
6346 }
6347
6348 gcc_assert (!winner);
6349 return 0;
6350}
6351
6352/* Given a list of candidates for overloading, find the best one, if any.
6353 This algorithm has a worst case of O(2n) (winner is last), and a best
6354 case of O(n/2) (totally ambiguous); much better than a sorting
6355 algorithm. */
6356
6357static struct z_candidate *
6358tourney (struct z_candidate *candidates)
6359{
6360 struct z_candidate *champ = candidates, *challenger;
6361 int fate;
6362 int champ_compared_to_predecessor = 0;
6363
6364 /* Walk through the list once, comparing each current champ to the next
6365 candidate, knocking out a candidate or two with each comparison. */
6366
6367 for (challenger = champ->next; challenger; )
6368 {
6369 fate = joust (champ, challenger, 0);
6370 if (fate == 1)
6371 challenger = challenger->next;
6372 else
6373 {
6374 if (fate == 0)
6375 {
6376 champ = challenger->next;
6377 if (champ == 0)
6378 return NULL;
6379 champ_compared_to_predecessor = 0;
6380 }
6381 else
6382 {
6383 champ = challenger;
6384 champ_compared_to_predecessor = 1;
6385 }
6386
6387 challenger = champ->next;
6388 }
6389 }
6390
6391 /* Make sure the champ is better than all the candidates it hasn't yet
6392 been compared to. */
6393
6394 for (challenger = candidates;
6395 challenger != champ
6396 && !(champ_compared_to_predecessor && challenger->next == champ);
6397 challenger = challenger->next)
6398 {
6399 fate = joust (champ, challenger, 0);
6400 if (fate != 1)
6401 return NULL;
6402 }
6403
6404 return champ;
6405}
6406
6407/* Returns nonzero if things of type FROM can be converted to TO. */
6408
6409bool
6410can_convert (tree to, tree from)
6411{
6412 return can_convert_arg (to, from, NULL_TREE, LOOKUP_NORMAL);
6413}
6414
6415/* Returns nonzero if ARG (of type FROM) can be converted to TO. */
6416
6417bool
6418can_convert_arg (tree to, tree from, tree arg, int flags)
6419{
6420 conversion *t;
6421 void *p;
6422 bool ok_p;
6423
6424 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6425 p = conversion_obstack_alloc (0);
6426
6427 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6428 flags);
6429 ok_p = (t && !t->bad_p);
6430
6431 /* Free all the conversions we allocated. */
6432 obstack_free (&conversion_obstack, p);
6433
6434 return ok_p;
6435}
6436
6437/* Like can_convert_arg, but allows dubious conversions as well. */
6438
6439bool
6440can_convert_arg_bad (tree to, tree from, tree arg)
6441{
6442 conversion *t;
6443 void *p;
6444
6445 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6446 p = conversion_obstack_alloc (0);
6447 /* Try to perform the conversion. */
6448 t = implicit_conversion (to, from, arg, /*c_cast_p=*/false,
6449 LOOKUP_NORMAL);
6450 /* Free all the conversions we allocated. */
6451 obstack_free (&conversion_obstack, p);
6452
6453 return t != NULL;
6454}
6455
6456/* Convert EXPR to TYPE. Return the converted expression.
6457
6458 Note that we allow bad conversions here because by the time we get to
6459 this point we are committed to doing the conversion. If we end up
6460 doing a bad conversion, convert_like will complain. */
6461
6462tree
6463perform_implicit_conversion (tree type, tree expr)
6464{
6465 conversion *conv;
6466 void *p;
6467
6468 if (error_operand_p (expr))
6469 return error_mark_node;
6470
6471 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6472 p = conversion_obstack_alloc (0);
6473
6474 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6475 /*c_cast_p=*/false,
6476 LOOKUP_NORMAL);
6477 if (!conv)
6478 {
6479 error ("could not convert %qE to %qT", expr, type);
6480 expr = error_mark_node;
6481 }
6482 else if (processing_template_decl)
6483 {
6484 /* In a template, we are only concerned about determining the
6485 type of non-dependent expressions, so we do not have to
6486 perform the actual conversion. */
6487 if (TREE_TYPE (expr) != type)
6488 expr = build_nop (type, expr);
6489 }
6490 else
6491 expr = convert_like (conv, expr);
6492
6493 /* Free all the conversions we allocated. */
6494 obstack_free (&conversion_obstack, p);
6495
6496 return expr;
6497}
6498
6499/* Convert EXPR to TYPE (as a direct-initialization) if that is
6500 permitted. If the conversion is valid, the converted expression is
6501 returned. Otherwise, NULL_TREE is returned, except in the case
6502 that TYPE is a class type; in that case, an error is issued. If
6503 C_CAST_P is true, then this direction initialization is taking
6504 place as part of a static_cast being attempted as part of a C-style
6505 cast. */
6506
6507tree
6508perform_direct_initialization_if_possible (tree type,
6509 tree expr,
6510 bool c_cast_p)
6511{
6512 conversion *conv;
6513 void *p;
6514
6515 if (type == error_mark_node || error_operand_p (expr))
6516 return error_mark_node;
6517 /* [dcl.init]
6518
6519 If the destination type is a (possibly cv-qualified) class type:
6520
6521 -- If the initialization is direct-initialization ...,
6522 constructors are considered. ... If no constructor applies, or
6523 the overload resolution is ambiguous, the initialization is
6524 ill-formed. */
6525 if (CLASS_TYPE_P (type))
6526 {
6527 expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
6528 build_tree_list (NULL_TREE, expr),
6529 type, LOOKUP_NORMAL);
6530 return build_cplus_new (type, expr);
6531 }
6532
6533 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6534 p = conversion_obstack_alloc (0);
6535
6536 conv = implicit_conversion (type, TREE_TYPE (expr), expr,
6537 c_cast_p,
6538 LOOKUP_NORMAL);
6539 if (!conv || conv->bad_p)
6540 expr = NULL_TREE;
6541 else
6542 expr = convert_like_real (conv, expr, NULL_TREE, 0, 0,
6543 /*issue_conversion_warnings=*/false,
6544 c_cast_p);
6545
6546 /* Free all the conversions we allocated. */
6547 obstack_free (&conversion_obstack, p);
6548
6549 return expr;
6550}
6551
6552/* DECL is a VAR_DECL whose type is a REFERENCE_TYPE. The reference
6553 is being bound to a temporary. Create and return a new VAR_DECL
6554 with the indicated TYPE; this variable will store the value to
6555 which the reference is bound. */
6556
6557tree
6558make_temporary_var_for_ref_to_temp (tree decl, tree type)
6559{
6560 tree var;
6561
6562 /* Create the variable. */
6563 var = create_temporary_var (type);
6564
6565 /* Register the variable. */
6566 if (TREE_STATIC (decl))
6567 {
6568 /* Namespace-scope or local static; give it a mangled name. */
6569 tree name;
6570
6571 TREE_STATIC (var) = 1;
6572 name = mangle_ref_init_variable (decl);
6573 DECL_NAME (var) = name;
6574 SET_DECL_ASSEMBLER_NAME (var, name);
6575 var = pushdecl_top_level (var);
6576 }
6577 else
6578 /* Create a new cleanup level if necessary. */
6579 maybe_push_cleanup_level (type);
6580
6581 return var;
6582}
6583
6584/* Convert EXPR to the indicated reference TYPE, in a way suitable for
6585 initializing a variable of that TYPE. If DECL is non-NULL, it is
6586 the VAR_DECL being initialized with the EXPR. (In that case, the
6587 type of DECL will be TYPE.) If DECL is non-NULL, then CLEANUP must
6588 also be non-NULL, and with *CLEANUP initialized to NULL. Upon
6589 return, if *CLEANUP is no longer NULL, it will be an expression
6590 that should be pushed as a cleanup after the returned expression
6591 is used to initialize DECL.
6592
6593 Return the converted expression. */
6594
6595tree
6596initialize_reference (tree type, tree expr, tree decl, tree *cleanup)
6597{
6598 conversion *conv;
6599 void *p;
6600
6601 if (type == error_mark_node || error_operand_p (expr))
6602 return error_mark_node;
6603
6604 /* Get the high-water mark for the CONVERSION_OBSTACK. */
6605 p = conversion_obstack_alloc (0);
6606
6607 conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false,
6608 LOOKUP_NORMAL);
6609 if (!conv || conv->bad_p)
6610 {
6611 if (!(TYPE_QUALS (TREE_TYPE (type)) & TYPE_QUAL_CONST)
6612 && !real_lvalue_p (expr))
6613 error ("invalid initialization of non-const reference of "
6614 "type %qT from a temporary of type %qT",
6615 type, TREE_TYPE (expr));
6616 else
6617 error ("invalid initialization of reference of type "
6618 "%qT from expression of type %qT", type,
6619 TREE_TYPE (expr));
6620 return error_mark_node;
6621 }
6622
6623 /* If DECL is non-NULL, then this special rule applies:
6624
6625 [class.temporary]
6626
6627 The temporary to which the reference is bound or the temporary
6628 that is the complete object to which the reference is bound
6629 persists for the lifetime of the reference.
6630
6631 The temporaries created during the evaluation of the expression
6632 initializing the reference, except the temporary to which the
6633 reference is bound, are destroyed at the end of the
6634 full-expression in which they are created.
6635
6636 In that case, we store the converted expression into a new
6637 VAR_DECL in a new scope.
6638
6639 However, we want to be careful not to create temporaries when
6640 they are not required. For example, given:
6641
6642 struct B {};
6643 struct D : public B {};
6644 D f();
6645 const B& b = f();
6646
6647 there is no need to copy the return value from "f"; we can just
6648 extend its lifetime. Similarly, given:
6649
6650 struct S {};
6651 struct T { operator S(); };
6652 T t;
6653 const S& s = t;
6654
6655 we can extend the lifetime of the return value of the conversion
6656 operator. */
6657 gcc_assert (conv->kind == ck_ref_bind);
6658 if (decl)
6659 {
6660 tree var;
6661 tree base_conv_type;
6662
6663 /* Skip over the REF_BIND. */
6664 conv = conv->u.next;
6665 /* If the next conversion is a BASE_CONV, skip that too -- but
6666 remember that the conversion was required. */
6667 if (conv->kind == ck_base)
6668 {
6669 if (conv->check_copy_constructor_p)
6670 check_constructor_callable (TREE_TYPE (expr), expr);
6671 base_conv_type = conv->type;
6672 conv = conv->u.next;
6673 }
6674 else
6675 base_conv_type = NULL_TREE;
6676 /* Perform the remainder of the conversion. */
6677 expr = convert_like_real (conv, expr,
6678 /*fn=*/NULL_TREE, /*argnum=*/0,
6679 /*inner=*/-1,
6680 /*issue_conversion_warnings=*/true,
6681 /*c_cast_p=*/false);
6682 if (error_operand_p (expr))
6683 expr = error_mark_node;
6684 else
6685 {
6686 if (!real_lvalue_p (expr))
6687 {
6688 tree init;
6689 tree type;
6690
6691 /* Create the temporary variable. */
6692 type = TREE_TYPE (expr);
6693 var = make_temporary_var_for_ref_to_temp (decl, type);
6694 layout_decl (var, 0);
6695 /* If the rvalue is the result of a function call it will be
6696 a TARGET_EXPR. If it is some other construct (such as a
6697 member access expression where the underlying object is
6698 itself the result of a function call), turn it into a
6699 TARGET_EXPR here. It is important that EXPR be a
6700 TARGET_EXPR below since otherwise the INIT_EXPR will
6701 attempt to make a bitwise copy of EXPR to initialize
6702 VAR. */
6703 if (TREE_CODE (expr) != TARGET_EXPR)
6704 expr = get_target_expr (expr);
6705 /* Create the INIT_EXPR that will initialize the temporary
6706 variable. */
6707 init = build2 (INIT_EXPR, type, var, expr);
6708 if (at_function_scope_p ())
6709 {
6710 add_decl_expr (var);
6711 *cleanup = cxx_maybe_build_cleanup (var);
6712
6713 /* We must be careful to destroy the temporary only
6714 after its initialization has taken place. If the
6715 initialization throws an exception, then the
6716 destructor should not be run. We cannot simply
6717 transform INIT into something like:
6718
6719 (INIT, ({ CLEANUP_STMT; }))
6720
6721 because emit_local_var always treats the
6722 initializer as a full-expression. Thus, the
6723 destructor would run too early; it would run at the
6724 end of initializing the reference variable, rather
6725 than at the end of the block enclosing the
6726 reference variable.
6727
6728 The solution is to pass back a cleanup expression
6729 which the caller is responsible for attaching to
6730 the statement tree. */
6731 }
6732 else
6733 {
6734 rest_of_decl_compilation (var, /*toplev=*/1, at_eof);
6735 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6736 static_aggregates = tree_cons (NULL_TREE, var,
6737 static_aggregates);
6738 }
6739 /* Use its address to initialize the reference variable. */
6740 expr = build_address (var);
6741 if (base_conv_type)
6742 expr = convert_to_base (expr,
6743 build_pointer_type (base_conv_type),
6744 /*check_access=*/true,
6745 /*nonnull=*/true);
6746 expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), init, expr);
6747 }
6748 else
6749 /* Take the address of EXPR. */
6750 expr = build_unary_op (ADDR_EXPR, expr, 0);
6751 /* If a BASE_CONV was required, perform it now. */
6752 if (base_conv_type)
6753 expr = (perform_implicit_conversion
6754 (build_pointer_type (base_conv_type), expr));
6755 expr = build_nop (type, expr);
6756 }
6757 }
6758 else
6759 /* Perform the conversion. */
6760 expr = convert_like (conv, expr);
6761
6762 /* Free all the conversions we allocated. */
6763 obstack_free (&conversion_obstack, p);
6764
6765 return expr;
6766}
6767
6768#include "gt-cp-call.h"
|