blob: c5601d96ab84d0739be90baa73af4a54f677e0b2 [file] [log] [blame]
/* Functions related to invoking -*- C++ -*- methods and overloaded functions.
Copyright (C) 1987-2021 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) and
modified by Brendan Kehoe (brendan@cygnus.com).
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
/* High-level class interface. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "target.h"
#include "cp-tree.h"
#include "timevar.h"
#include "stringpool.h"
#include "cgraph.h"
#include "stor-layout.h"
#include "trans-mem.h"
#include "flags.h"
#include "toplev.h"
#include "intl.h"
#include "convert.h"
#include "langhooks.h"
#include "c-family/c-objc.h"
#include "internal-fn.h"
#include "stringpool.h"
#include "attribs.h"
#include "gcc-rich-location.h"
/* The various kinds of conversion. */
enum conversion_kind {
ck_identity,
ck_lvalue,
ck_fnptr,
ck_qual,
ck_std,
ck_ptr,
ck_pmem,
ck_base,
ck_ref_bind,
ck_user,
ck_ambig,
ck_list,
ck_aggr,
ck_rvalue
};
/* The rank of the conversion. Order of the enumerals matters; better
conversions should come earlier in the list. */
enum conversion_rank {
cr_identity,
cr_exact,
cr_promotion,
cr_std,
cr_pbool,
cr_user,
cr_ellipsis,
cr_bad
};
/* An implicit conversion sequence, in the sense of [over.best.ics].
The first conversion to be performed is at the end of the chain.
That conversion is always a cr_identity conversion. */
struct conversion {
/* The kind of conversion represented by this step. */
conversion_kind kind;
/* The rank of this conversion. */
conversion_rank rank;
BOOL_BITFIELD user_conv_p : 1;
BOOL_BITFIELD ellipsis_p : 1;
BOOL_BITFIELD this_p : 1;
/* True if this conversion would be permitted with a bending of
language standards, e.g. disregarding pointer qualifiers or
converting integers to pointers. */
BOOL_BITFIELD bad_p : 1;
/* If KIND is ck_ref_bind or ck_base, true to indicate that a
temporary should be created to hold the result of the
conversion. If KIND is ck_ambig or ck_user, true means force
copy-initialization. */
BOOL_BITFIELD need_temporary_p : 1;
/* If KIND is ck_ptr or ck_pmem, true to indicate that a conversion
from a pointer-to-derived to pointer-to-base is being performed. */
BOOL_BITFIELD base_p : 1;
/* If KIND is ck_ref_bind, true when either an lvalue reference is
being bound to an lvalue expression or an rvalue reference is
being bound to an rvalue expression. If KIND is ck_rvalue or ck_base,
true when we are treating an lvalue as an rvalue (12.8p33). If
ck_identity, we will be binding a reference directly or decaying to
a pointer. */
BOOL_BITFIELD rvaluedness_matches_p: 1;
BOOL_BITFIELD check_narrowing: 1;
/* Whether check_narrowing should only check TREE_CONSTANTs; used
in build_converted_constant_expr. */
BOOL_BITFIELD check_narrowing_const_only: 1;
/* True if this conversion is taking place in a copy-initialization context
and we should only consider converting constructors. Only set in
ck_base and ck_rvalue. */
BOOL_BITFIELD copy_init_p : 1;
/* The type of the expression resulting from the conversion. */
tree type;
union {
/* The next conversion in the chain. Since the conversions are
arranged from outermost to innermost, the NEXT conversion will
actually be performed before this conversion. This variant is
used only when KIND is neither ck_identity, ck_aggr, ck_ambig nor
ck_list. Please use the next_conversion function instead
of using this field directly. */
conversion *next;
/* The expression at the beginning of the conversion chain. This
variant is used only if KIND is ck_identity, ck_aggr, or ck_ambig.
You can use conv_get_original_expr to get this expression. */
tree expr;
/* The array of conversions for an initializer_list, so this
variant is used only when KIN D is ck_list. */
conversion **list;
} u;
/* The function candidate corresponding to this conversion
sequence. This field is only used if KIND is ck_user. */
struct z_candidate *cand;
};
#define CONVERSION_RANK(NODE) \
((NODE)->bad_p ? cr_bad \
: (NODE)->ellipsis_p ? cr_ellipsis \
: (NODE)->user_conv_p ? cr_user \
: (NODE)->rank)
#define BAD_CONVERSION_RANK(NODE) \
((NODE)->ellipsis_p ? cr_ellipsis \
: (NODE)->user_conv_p ? cr_user \
: (NODE)->rank)
static struct obstack conversion_obstack;
static bool conversion_obstack_initialized;
struct rejection_reason;
static struct z_candidate * tourney (struct z_candidate *, tsubst_flags_t);
static int equal_functions (tree, tree);
static int joust (struct z_candidate *, struct z_candidate *, bool,
tsubst_flags_t);
static int compare_ics (conversion *, conversion *);
static void maybe_warn_class_memaccess (location_t, tree,
const vec<tree, va_gc> *);
static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
static tree convert_like (conversion *, tree, tsubst_flags_t);
static tree convert_like_with_context (conversion *, tree, tree, int,
tsubst_flags_t);
static void op_error (const op_location_t &, enum tree_code, enum tree_code,
tree, tree, tree, bool);
static struct z_candidate *build_user_type_conversion_1 (tree, tree, int,
tsubst_flags_t);
static void print_z_candidate (location_t, const char *, struct z_candidate *);
static void print_z_candidates (location_t, struct z_candidate *);
static tree build_this (tree);
static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
static bool any_strictly_viable (struct z_candidate *);
static struct z_candidate *add_template_candidate
(struct z_candidate **, tree, tree, tree, tree, const vec<tree, va_gc> *,
tree, tree, tree, int, unification_kind_t, bool, tsubst_flags_t);
static struct z_candidate *add_template_candidate_real
(struct z_candidate **, tree, tree, tree, tree, const vec<tree, va_gc> *,
tree, tree, tree, int, tree, unification_kind_t, bool, tsubst_flags_t);
static bool is_complete (tree);
static struct z_candidate *add_conv_candidate
(struct z_candidate **, tree, tree, const vec<tree, va_gc> *, tree,
tree, tsubst_flags_t);
static struct z_candidate *add_function_candidate
(struct z_candidate **, tree, tree, tree, const vec<tree, va_gc> *, tree,
tree, int, conversion**, bool, tsubst_flags_t);
static conversion *implicit_conversion (tree, tree, tree, bool, int,
tsubst_flags_t);
static conversion *reference_binding (tree, tree, tree, bool, int,
tsubst_flags_t);
static conversion *build_conv (conversion_kind, tree, conversion *);
static conversion *build_list_conv (tree, tree, int, tsubst_flags_t);
static conversion *next_conversion (conversion *);
static bool is_subseq (conversion *, conversion *);
static conversion *maybe_handle_ref_bind (conversion **);
static void maybe_handle_implicit_object (conversion **);
static struct z_candidate *add_candidate
(struct z_candidate **, tree, tree, const vec<tree, va_gc> *, size_t,
conversion **, tree, tree, int, struct rejection_reason *, int);
static tree source_type (conversion *);
static void add_warning (struct z_candidate *, struct z_candidate *);
static conversion *direct_reference_binding (tree, conversion *);
static bool promoted_arithmetic_type_p (tree);
static conversion *conditional_conversion (tree, tree, tsubst_flags_t);
static char *name_as_c_string (tree, tree, bool *);
static tree prep_operand (tree);
static void add_candidates (tree, tree, const vec<tree, va_gc> *, tree, tree,
bool, tree, tree, int, struct z_candidate **,
tsubst_flags_t);
static conversion *merge_conversion_sequences (conversion *, conversion *);
static tree build_temp (tree, tree, int, diagnostic_t *, tsubst_flags_t);
static conversion *build_identity_conv (tree, tree);
static inline bool conv_binds_to_array_of_unknown_bound (conversion *);
static bool conv_is_prvalue (conversion *);
static tree prevent_lifetime_extension (tree);
/* Returns nonzero iff the destructor name specified in NAME matches BASETYPE.
NAME can take many forms... */
bool
check_dtor_name (tree basetype, tree name)
{
/* Just accept something we've already complained about. */
if (name == error_mark_node)
return true;
if (TREE_CODE (name) == TYPE_DECL)
name = TREE_TYPE (name);
else if (TYPE_P (name))
/* OK */;
else if (identifier_p (name))
{
if ((MAYBE_CLASS_TYPE_P (basetype)
|| TREE_CODE (basetype) == ENUMERAL_TYPE)
&& name == constructor_name (basetype))
return true;
/* Otherwise lookup the name, it could be an unrelated typedef
of the correct type. */
name = lookup_name (name, LOOK_want::TYPE);
if (!name)
return false;
name = TREE_TYPE (name);
if (name == error_mark_node)
return false;
}
else
{
/* In the case of:
template <class T> struct S { ~S(); };
int i;
i.~S();
NAME will be a class template. */
gcc_assert (DECL_CLASS_TEMPLATE_P (name));
return false;
}
return same_type_p (TYPE_MAIN_VARIANT (basetype), TYPE_MAIN_VARIANT (name));
}
/* We want the address of a function or method. We avoid creating a
pointer-to-member function. */
tree
build_addr_func (tree function, tsubst_flags_t complain)
{
tree type = TREE_TYPE (function);
/* We have to do these by hand to avoid real pointer to member
functions. */
if (TREE_CODE (type) == METHOD_TYPE)
{
if (TREE_CODE (function) == OFFSET_REF)
{
tree object = build_address (TREE_OPERAND (function, 0));
return get_member_function_from_ptrfunc (&object,
TREE_OPERAND (function, 1),
complain);
}
function = build_address (function);
}
else if (TREE_CODE (function) == FUNCTION_DECL
&& DECL_IMMEDIATE_FUNCTION_P (function))
function = build_address (function);
else
function = decay_conversion (function, complain, /*reject_builtin=*/false);
return function;
}
/* Build a CALL_EXPR, we can handle FUNCTION_TYPEs, METHOD_TYPEs, or
POINTER_TYPE to those. Note, pointer to member function types
(TYPE_PTRMEMFUNC_P) must be handled by our callers. There are
two variants. build_call_a is the primitive taking an array of
arguments, while build_call_n is a wrapper that handles varargs. */
tree
build_call_n (tree function, int n, ...)
{
if (n == 0)
return build_call_a (function, 0, NULL);
else
{
tree *argarray = XALLOCAVEC (tree, n);
va_list ap;
int i;
va_start (ap, n);
for (i = 0; i < n; i++)
argarray[i] = va_arg (ap, tree);
va_end (ap);
return build_call_a (function, n, argarray);
}
}
/* Update various flags in cfun and the call itself based on what is being
called. Split out of build_call_a so that bot_manip can use it too. */
void
set_flags_from_callee (tree call)
{
/* Handle both CALL_EXPRs and AGGR_INIT_EXPRs. */
tree decl = cp_get_callee_fndecl_nofold (call);
/* We check both the decl and the type; a function may be known not to
throw without being declared throw(). */
bool nothrow = decl && TREE_NOTHROW (decl);
tree callee = cp_get_callee (call);
if (callee)
nothrow |= TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (callee)));
else if (TREE_CODE (call) == CALL_EXPR
&& internal_fn_flags (CALL_EXPR_IFN (call)) & ECF_NOTHROW)
nothrow = true;
if (cfun && cp_function_chain && !cp_unevaluated_operand)
{
if (!nothrow && at_function_scope_p ())
cp_function_chain->can_throw = 1;
if (decl && TREE_THIS_VOLATILE (decl))
current_function_returns_abnormally = 1;
}
TREE_NOTHROW (call) = nothrow;
}
tree
build_call_a (tree function, int n, tree *argarray)
{
tree decl;
tree result_type;
tree fntype;
int i;
function = build_addr_func (function, tf_warning_or_error);
gcc_assert (TYPE_PTR_P (TREE_TYPE (function)));
fntype = TREE_TYPE (TREE_TYPE (function));
gcc_assert (FUNC_OR_METHOD_TYPE_P (fntype));
result_type = TREE_TYPE (fntype);
/* An rvalue has no cv-qualifiers. */
if (SCALAR_TYPE_P (result_type) || VOID_TYPE_P (result_type))
result_type = cv_unqualified (result_type);
function = build_call_array_loc (input_location,
result_type, function, n, argarray);
set_flags_from_callee (function);
decl = get_callee_fndecl (function);
if (decl && !TREE_USED (decl))
{
/* We invoke build_call directly for several library
functions. These may have been declared normally if
we're building libgcc, so we can't just check
DECL_ARTIFICIAL. */
gcc_assert (DECL_ARTIFICIAL (decl)
|| !strncmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
"__", 2));
mark_used (decl);
}
require_complete_eh_spec_types (fntype, decl);
TREE_HAS_CONSTRUCTOR (function) = (decl && DECL_CONSTRUCTOR_P (decl));
/* Don't pass empty class objects by value. This is useful
for tags in STL, which are used to control overload resolution.
We don't need to handle other cases of copying empty classes. */
if (!decl || !fndecl_built_in_p (decl))
for (i = 0; i < n; i++)
{
tree arg = CALL_EXPR_ARG (function, i);
if (is_empty_class (TREE_TYPE (arg))
&& simple_empty_class_p (TREE_TYPE (arg), arg, INIT_EXPR))
{
while (TREE_CODE (arg) == TARGET_EXPR)
/* We're disconnecting the initializer from its target,
don't create a temporary. */
arg = TARGET_EXPR_INITIAL (arg);
tree t = build0 (EMPTY_CLASS_EXPR, TREE_TYPE (arg));
arg = build2 (COMPOUND_EXPR, TREE_TYPE (t), arg, t);
CALL_EXPR_ARG (function, i) = arg;
}
}
return function;
}
/* New overloading code. */
struct z_candidate;
struct candidate_warning {
z_candidate *loser;
candidate_warning *next;
};
/* Information for providing diagnostics about why overloading failed. */
enum rejection_reason_code {
rr_none,
rr_arity,
rr_explicit_conversion,
rr_template_conversion,
rr_arg_conversion,
rr_bad_arg_conversion,
rr_template_unification,
rr_invalid_copy,
rr_inherited_ctor,
rr_constraint_failure
};
struct conversion_info {
/* The index of the argument, 0-based. */
int n_arg;
/* The actual argument or its type. */
tree from;
/* The type of the parameter. */
tree to_type;
/* The location of the argument. */
location_t loc;
};
struct rejection_reason {
enum rejection_reason_code code;
union {
/* Information about an arity mismatch. */
struct {
/* The expected number of arguments. */
int expected;
/* The actual number of arguments in the call. */
int actual;
/* Whether EXPECTED should be treated as a lower bound. */
bool least_p;
} arity;
/* Information about an argument conversion mismatch. */
struct conversion_info conversion;
/* Same, but for bad argument conversions. */
struct conversion_info bad_conversion;
/* Information about template unification failures. These are the
parameters passed to fn_type_unification. */
struct {
tree tmpl;
tree explicit_targs;
int num_targs;
const tree *args;
unsigned int nargs;
tree return_type;
unification_kind_t strict;
int flags;
} template_unification;
/* Information about template instantiation failures. These are the
parameters passed to instantiate_template. */
struct {
tree tmpl;
tree targs;
} template_instantiation;
} u;
};
struct z_candidate {
/* The FUNCTION_DECL that will be called if this candidate is
selected by overload resolution. */
tree fn;
/* If not NULL_TREE, the first argument to use when calling this
function. */
tree first_arg;
/* The rest of the arguments to use when calling this function. If
there are no further arguments this may be NULL or it may be an
empty vector. */
const vec<tree, va_gc> *args;
/* The implicit conversion sequences for each of the arguments to
FN. */
conversion **convs;
/* The number of implicit conversion sequences. */
size_t num_convs;
/* If FN is a user-defined conversion, the standard conversion
sequence from the type returned by FN to the desired destination
type. */
conversion *second_conv;
struct rejection_reason *reason;
/* If FN is a member function, the binfo indicating the path used to
qualify the name of FN at the call site. This path is used to
determine whether or not FN is accessible if it is selected by
overload resolution. The DECL_CONTEXT of FN will always be a
(possibly improper) base of this binfo. */
tree access_path;
/* If FN is a non-static member function, the binfo indicating the
subobject to which the `this' pointer should be converted if FN
is selected by overload resolution. The type pointed to by
the `this' pointer must correspond to the most derived class
indicated by the CONVERSION_PATH. */
tree conversion_path;
tree template_decl;
tree explicit_targs;
candidate_warning *warnings;
z_candidate *next;
int viable;
/* The flags active in add_candidate. */
int flags;
bool rewritten () const { return (flags & LOOKUP_REWRITTEN); }
bool reversed () const { return (flags & LOOKUP_REVERSED); }
};
/* Returns true iff T is a null pointer constant in the sense of
[conv.ptr]. */
bool
null_ptr_cst_p (tree t)
{
tree type = TREE_TYPE (t);
/* [conv.ptr]
A null pointer constant is an integer literal ([lex.icon]) with value
zero or a prvalue of type std::nullptr_t. */
if (NULLPTR_TYPE_P (type))
return true;
if (cxx_dialect >= cxx11)
{
STRIP_ANY_LOCATION_WRAPPER (t);
/* Core issue 903 says only literal 0 is a null pointer constant. */
if (TREE_CODE (t) == INTEGER_CST
&& !TREE_OVERFLOW (t)
&& TREE_CODE (type) == INTEGER_TYPE
&& integer_zerop (t)
&& !char_type_p (type))
return true;
}
else if (CP_INTEGRAL_TYPE_P (type))
{
t = fold_non_dependent_expr (t, tf_none);
STRIP_NOPS (t);
if (integer_zerop (t) && !TREE_OVERFLOW (t))
return true;
}
return false;
}
/* Returns true iff T is a null member pointer value (4.11). */
bool
null_member_pointer_value_p (tree t)
{
tree type = TREE_TYPE (t);
if (!type)
return false;
else if (TYPE_PTRMEMFUNC_P (type))
return (TREE_CODE (t) == CONSTRUCTOR
&& CONSTRUCTOR_NELTS (t)
&& integer_zerop (CONSTRUCTOR_ELT (t, 0)->value));
else if (TYPE_PTRDATAMEM_P (type))
return integer_all_onesp (t);
else
return false;
}
/* Returns nonzero if PARMLIST consists of only default parms,
ellipsis, and/or undeduced parameter packs. */
bool
sufficient_parms_p (const_tree parmlist)
{
for (; parmlist && parmlist != void_list_node;
parmlist = TREE_CHAIN (parmlist))
if (!TREE_PURPOSE (parmlist)
&& !PACK_EXPANSION_P (TREE_VALUE (parmlist)))
return false;
return true;
}
/* Allocate N bytes of memory from the conversion obstack. The memory
is zeroed before being returned. */
static void *
conversion_obstack_alloc (size_t n)
{
void *p;
if (!conversion_obstack_initialized)
{
gcc_obstack_init (&conversion_obstack);
conversion_obstack_initialized = true;
}
p = obstack_alloc (&conversion_obstack, n);
memset (p, 0, n);
return p;
}
/* Allocate rejection reasons. */
static struct rejection_reason *
alloc_rejection (enum rejection_reason_code code)
{
struct rejection_reason *p;
p = (struct rejection_reason *) conversion_obstack_alloc (sizeof *p);
p->code = code;
return p;
}
static struct rejection_reason *
arity_rejection (tree first_arg, int expected, int actual, bool least_p = false)
{
struct rejection_reason *r = alloc_rejection (rr_arity);
int adjust = first_arg != NULL_TREE;
r->u.arity.expected = expected - adjust;
r->u.arity.actual = actual - adjust;
r->u.arity.least_p = least_p;
return r;
}
static struct rejection_reason *
arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to,
location_t loc)
{
struct rejection_reason *r = alloc_rejection (rr_arg_conversion);
int adjust = first_arg != NULL_TREE;
r->u.conversion.n_arg = n_arg - adjust;
r->u.conversion.from = from;
r->u.conversion.to_type = to;
r->u.conversion.loc = loc;
return r;
}
static struct rejection_reason *
bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to,
location_t loc)
{
struct rejection_reason *r = alloc_rejection (rr_bad_arg_conversion);
int adjust = first_arg != NULL_TREE;
r->u.bad_conversion.n_arg = n_arg - adjust;
r->u.bad_conversion.from = from;
r->u.bad_conversion.to_type = to;
r->u.bad_conversion.loc = loc;
return r;
}
static struct rejection_reason *
explicit_conversion_rejection (tree from, tree to)
{
struct rejection_reason *r = alloc_rejection (rr_explicit_conversion);
r->u.conversion.n_arg = 0;
r->u.conversion.from = from;
r->u.conversion.to_type = to;
r->u.conversion.loc = UNKNOWN_LOCATION;
return r;
}
static struct rejection_reason *
template_conversion_rejection (tree from, tree to)
{
struct rejection_reason *r = alloc_rejection (rr_template_conversion);
r->u.conversion.n_arg = 0;
r->u.conversion.from = from;
r->u.conversion.to_type = to;
r->u.conversion.loc = UNKNOWN_LOCATION;
return r;
}
static struct rejection_reason *
template_unification_rejection (tree tmpl, tree explicit_targs, tree targs,
const tree *args, unsigned int nargs,
tree return_type, unification_kind_t strict,
int flags)
{
size_t args_n_bytes = sizeof (*args) * nargs;
tree *args1 = (tree *) conversion_obstack_alloc (args_n_bytes);
struct rejection_reason *r = alloc_rejection (rr_template_unification);
r->u.template_unification.tmpl = tmpl;
r->u.template_unification.explicit_targs = explicit_targs;
r->u.template_unification.num_targs = TREE_VEC_LENGTH (targs);
/* Copy args to our own storage. */
memcpy (args1, args, args_n_bytes);
r->u.template_unification.args = args1;
r->u.template_unification.nargs = nargs;
r->u.template_unification.return_type = return_type;
r->u.template_unification.strict = strict;
r->u.template_unification.flags = flags;
return r;
}
static struct rejection_reason *
template_unification_error_rejection (void)
{
return alloc_rejection (rr_template_unification);
}
static struct rejection_reason *
invalid_copy_with_fn_template_rejection (void)
{
struct rejection_reason *r = alloc_rejection (rr_invalid_copy);
return r;
}
static struct rejection_reason *
inherited_ctor_rejection (void)
{
struct rejection_reason *r = alloc_rejection (rr_inherited_ctor);
return r;
}
/* Build a constraint failure record. */
static struct rejection_reason *
constraint_failure (void)
{
struct rejection_reason *r = alloc_rejection (rr_constraint_failure);
return r;
}
/* Dynamically allocate a conversion. */
static conversion *
alloc_conversion (conversion_kind kind)
{
conversion *c;
c = (conversion *) conversion_obstack_alloc (sizeof (conversion));
c->kind = kind;
return c;
}
/* Make sure that all memory on the conversion obstack has been
freed. */
void
validate_conversion_obstack (void)
{
if (conversion_obstack_initialized)
gcc_assert ((obstack_next_free (&conversion_obstack)
== obstack_base (&conversion_obstack)));
}
/* Dynamically allocate an array of N conversions. */
static conversion **
alloc_conversions (size_t n)
{
return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *));
}
/* True iff the active member of conversion::u for code CODE is NEXT. */
static inline bool
has_next (conversion_kind code)
{
return !(code == ck_identity
|| code == ck_ambig
|| code == ck_list
|| code == ck_aggr);
}
static conversion *
build_conv (conversion_kind code, tree type, conversion *from)
{
conversion *t;
conversion_rank rank = CONVERSION_RANK (from);
/* Only call this function for conversions that use u.next. */
gcc_assert (from == NULL || has_next (code));
/* Note that the caller is responsible for filling in t->cand for
user-defined conversions. */
t = alloc_conversion (code);
t->type = type;
t->u.next = from;
switch (code)
{
case ck_ptr:
case ck_pmem:
case ck_base:
case ck_std:
if (rank < cr_std)
rank = cr_std;
break;
case ck_qual:
case ck_fnptr:
if (rank < cr_exact)
rank = cr_exact;
break;
default:
break;
}
t->rank = rank;
t->user_conv_p = (code == ck_user || from->user_conv_p);
t->bad_p = from->bad_p;
t->base_p = false;
return t;
}
/* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
specialization of std::initializer_list<T>, if such a conversion is
possible. */
static conversion *
build_list_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
{
tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (type), 0);
unsigned len = CONSTRUCTOR_NELTS (ctor);
conversion **subconvs = alloc_conversions (len);
conversion *t;
unsigned i;
tree val;
/* Within a list-initialization we can have more user-defined
conversions. */
flags &= ~LOOKUP_NO_CONVERSION;
/* But no narrowing conversions. */
flags |= LOOKUP_NO_NARROWING;
/* Can't make an array of these types. */
if (TYPE_REF_P (elttype)
|| TREE_CODE (elttype) == FUNCTION_TYPE
|| VOID_TYPE_P (elttype))
return NULL;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
{
conversion *sub
= implicit_conversion (elttype, TREE_TYPE (val), val,
false, flags, complain);
if (sub == NULL)
return NULL;
subconvs[i] = sub;
}
t = alloc_conversion (ck_list);
t->type = type;
t->u.list = subconvs;
t->rank = cr_exact;
for (i = 0; i < len; ++i)
{
conversion *sub = subconvs[i];
if (sub->rank > t->rank)
t->rank = sub->rank;
if (sub->user_conv_p)
t->user_conv_p = true;
if (sub->bad_p)
t->bad_p = true;
}
return t;
}
/* Return the next conversion of the conversion chain (if applicable),
or NULL otherwise. Please use this function instead of directly
accessing fields of struct conversion. */
static conversion *
next_conversion (conversion *conv)
{
if (conv == NULL
|| !has_next (conv->kind))
return NULL;
return conv->u.next;
}
/* Strip to the first ck_user, ck_ambig, ck_list, ck_aggr or ck_identity
encountered. */
static conversion *
strip_standard_conversion (conversion *conv)
{
while (conv
&& conv->kind != ck_user
&& has_next (conv->kind))
conv = next_conversion (conv);
return conv;
}
/* Subroutine of build_aggr_conv: check whether FROM is a valid aggregate
initializer for array type ATYPE. */
static bool
can_convert_array (tree atype, tree from, int flags, tsubst_flags_t complain)
{
tree elttype = TREE_TYPE (atype);
unsigned i;
if (TREE_CODE (from) == CONSTRUCTOR)
{
for (i = 0; i < CONSTRUCTOR_NELTS (from); ++i)
{
tree val = CONSTRUCTOR_ELT (from, i)->value;
bool ok;
if (TREE_CODE (elttype) == ARRAY_TYPE)
ok = can_convert_array (elttype, val, flags, complain);
else
ok = can_convert_arg (elttype, TREE_TYPE (val), val, flags,
complain);
if (!ok)
return false;
}
return true;
}
if (char_type_p (TYPE_MAIN_VARIANT (elttype))
&& TREE_CODE (tree_strip_any_location_wrapper (from)) == STRING_CST)
return array_string_literal_compatible_p (atype, from);
/* No other valid way to aggregate initialize an array. */
return false;
}
/* Helper for build_aggr_conv. Return true if FIELD is in PSET, or if
FIELD has ANON_AGGR_TYPE_P and any initializable field in there recursively
is in PSET. */
static bool
field_in_pset (hash_set<tree, true> &pset, tree field)
{
if (pset.contains (field))
return true;
if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
for (field = TYPE_FIELDS (TREE_TYPE (field));
field; field = DECL_CHAIN (field))
{
field = next_initializable_field (field);
if (field == NULL_TREE)
break;
if (field_in_pset (pset, field))
return true;
}
return false;
}
/* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
aggregate class, if such a conversion is possible. */
static conversion *
build_aggr_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
{
unsigned HOST_WIDE_INT i = 0;
conversion *c;
tree field = next_initializable_field (TYPE_FIELDS (type));
tree empty_ctor = NULL_TREE;
hash_set<tree, true> pset;
/* We already called reshape_init in implicit_conversion. */
/* The conversions within the init-list aren't affected by the enclosing
context; they're always simple copy-initialization. */
flags = LOOKUP_IMPLICIT|LOOKUP_NO_NARROWING;
/* For designated initializers, verify that each initializer is convertible
to corresponding TREE_TYPE (ce->index) and mark those FIELD_DECLs as
visited. In the following loop then ignore already visited
FIELD_DECLs. */
if (CONSTRUCTOR_IS_DESIGNATED_INIT (ctor))
{
tree idx, val;
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), i, idx, val)
{
if (idx && TREE_CODE (idx) == FIELD_DECL)
{
tree ftype = TREE_TYPE (idx);
bool ok;
if (TREE_CODE (ftype) == ARRAY_TYPE)
ok = can_convert_array (ftype, val, flags, complain);
else
ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags,
complain);
if (!ok)
return NULL;
/* For unions, there should be just one initializer. */
if (TREE_CODE (type) == UNION_TYPE)
{
field = NULL_TREE;
i = 1;
break;
}
pset.add (idx);
}
else
return NULL;
}
}
for (; field; field = next_initializable_field (DECL_CHAIN (field)))
{
tree ftype = TREE_TYPE (field);
tree val;
bool ok;
if (!pset.is_empty () && field_in_pset (pset, field))
continue;
if (i < CONSTRUCTOR_NELTS (ctor))
{
val = CONSTRUCTOR_ELT (ctor, i)->value;
++i;
}
else if (DECL_INITIAL (field))
val = get_nsdmi (field, /*ctor*/false, complain);
else if (TYPE_REF_P (ftype))
/* Value-initialization of reference is ill-formed. */
return NULL;
else
{
if (empty_ctor == NULL_TREE)
empty_ctor = build_constructor (init_list_type_node, NULL);
val = empty_ctor;
}
if (TREE_CODE (ftype) == ARRAY_TYPE)
ok = can_convert_array (ftype, val, flags, complain);
else
ok = can_convert_arg (ftype, TREE_TYPE (val), val, flags,
complain);
if (!ok)
return NULL;
if (TREE_CODE (type) == UNION_TYPE)
break;
}
if (i < CONSTRUCTOR_NELTS (ctor))
return NULL;
c = alloc_conversion (ck_aggr);
c->type = type;
c->rank = cr_exact;
c->user_conv_p = true;
c->check_narrowing = true;
c->u.expr = ctor;
return c;
}
/* Represent a conversion from CTOR, a braced-init-list, to TYPE, an
array type, if such a conversion is possible. */
static conversion *
build_array_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
{
conversion *c;
unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
tree elttype = TREE_TYPE (type);
unsigned i;
tree val;
bool bad = false;
bool user = false;
enum conversion_rank rank = cr_exact;
/* We might need to propagate the size from the element to the array. */
complete_type (type);
if (TYPE_DOMAIN (type)
&& !variably_modified_type_p (TYPE_DOMAIN (type), NULL_TREE))
{
unsigned HOST_WIDE_INT alen = tree_to_uhwi (array_type_nelts_top (type));
if (alen < len)
return NULL;
}
flags = LOOKUP_IMPLICIT|LOOKUP_NO_NARROWING;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
{
conversion *sub
= implicit_conversion (elttype, TREE_TYPE (val), val,
false, flags, complain);
if (sub == NULL)
return NULL;
if (sub->rank > rank)
rank = sub->rank;
if (sub->user_conv_p)
user = true;
if (sub->bad_p)
bad = true;
}
c = alloc_conversion (ck_aggr);
c->type = type;
c->rank = rank;
c->user_conv_p = user;
c->bad_p = bad;
c->u.expr = ctor;
return c;
}
/* Represent a conversion from CTOR, a braced-init-list, to TYPE, a
complex type, if such a conversion is possible. */
static conversion *
build_complex_conv (tree type, tree ctor, int flags,
tsubst_flags_t complain)
{
conversion *c;
unsigned HOST_WIDE_INT len = CONSTRUCTOR_NELTS (ctor);
tree elttype = TREE_TYPE (type);
unsigned i;
tree val;
bool bad = false;
bool user = false;
enum conversion_rank rank = cr_exact;
if (len != 2)
return NULL;
flags = LOOKUP_IMPLICIT|LOOKUP_NO_NARROWING;
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), i, val)
{
conversion *sub
= implicit_conversion (elttype, TREE_TYPE (val), val,
false, flags, complain);
if (sub == NULL)
return NULL;
if (sub->rank > rank)
rank = sub->rank;
if (sub->user_conv_p)
user = true;
if (sub->bad_p)
bad = true;
}
c = alloc_conversion (ck_aggr);
c->type = type;
c->rank = rank;
c->user_conv_p = user;
c->bad_p = bad;
c->u.expr = ctor;
return c;
}
/* Build a representation of the identity conversion from EXPR to
itself. The TYPE should match the type of EXPR, if EXPR is non-NULL. */
static conversion *
build_identity_conv (tree type, tree expr)
{
conversion *c;
c = alloc_conversion (ck_identity);
c->type = type;
c->u.expr = expr;
return c;
}
/* Converting from EXPR to TYPE was ambiguous in the sense that there
were multiple user-defined conversions to accomplish the job.
Build a conversion that indicates that ambiguity. */
static conversion *
build_ambiguous_conv (tree type, tree expr)
{
conversion *c;
c = alloc_conversion (ck_ambig);
c->type = type;
c->u.expr = expr;
return c;
}
tree
strip_top_quals (tree t)
{
if (TREE_CODE (t) == ARRAY_TYPE)
return t;
return cp_build_qualified_type (t, 0);
}
/* Returns the standard conversion path (see [conv]) from type FROM to type
TO, if any. For proper handling of null pointer constants, you must
also pass the expression EXPR to convert from. If C_CAST_P is true,
this conversion is coming from a C-style cast. */
static conversion *
standard_conversion (tree to, tree from, tree expr, bool c_cast_p,
int flags, tsubst_flags_t complain)
{
enum tree_code fcode, tcode;
conversion *conv;
bool fromref = false;
tree qualified_to;
to = non_reference (to);
if (TYPE_REF_P (from))
{
fromref = true;
from = TREE_TYPE (from);
}
qualified_to = to;
to = strip_top_quals (to);
from = strip_top_quals (from);
if (expr && type_unknown_p (expr))
{
if (TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to))
{
tsubst_flags_t tflags = tf_conv;
expr = instantiate_type (to, expr, tflags);
if (expr == error_mark_node)
return NULL;
from = TREE_TYPE (expr);
}
else if (TREE_CODE (to) == BOOLEAN_TYPE)
{
/* Necessary for eg, TEMPLATE_ID_EXPRs (c++/50961). */
expr = resolve_nondeduced_context (expr, complain);
from = TREE_TYPE (expr);
}
}
fcode = TREE_CODE (from);
tcode = TREE_CODE (to);
conv = build_identity_conv (from, expr);
if (fcode == FUNCTION_TYPE || fcode == ARRAY_TYPE)
{
from = type_decays_to (from);
fcode = TREE_CODE (from);
/* Tell convert_like that we're using the address. */
conv->rvaluedness_matches_p = true;
conv = build_conv (ck_lvalue, from, conv);
}
/* Wrapping a ck_rvalue around a class prvalue (as a result of using
obvalue_p) seems odd, since it's already a prvalue, but that's how we
express the copy constructor call required by copy-initialization. */
else if (fromref || (expr && obvalue_p (expr)))
{
if (expr)
{
tree bitfield_type;
bitfield_type = is_bitfield_expr_with_lowered_type (expr);
if (bitfield_type)
{
from = strip_top_quals (bitfield_type);
fcode = TREE_CODE (from);
}
}
conv = build_conv (ck_rvalue, from, conv);
if (flags & LOOKUP_PREFER_RVALUE)
/* Tell convert_like to set LOOKUP_PREFER_RVALUE. */
conv->rvaluedness_matches_p = true;
/* If we're performing copy-initialization, remember to skip
explicit constructors. */
if (flags & LOOKUP_ONLYCONVERTING)
conv->copy_init_p = true;
}
/* Allow conversion between `__complex__' data types. */
if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
{
/* The standard conversion sequence to convert FROM to TO is
the standard conversion sequence to perform componentwise
conversion. */
conversion *part_conv = standard_conversion
(TREE_TYPE (to), TREE_TYPE (from), NULL_TREE, c_cast_p, flags,
complain);
if (!part_conv)
conv = NULL;
else if (part_conv->kind == ck_identity)
/* Leave conv alone. */;
else
{
conv = build_conv (part_conv->kind, to, conv);
conv->rank = part_conv->rank;
}
return conv;
}
if (same_type_p (from, to))
{
if (CLASS_TYPE_P (to) && conv->kind == ck_rvalue)
conv->type = qualified_to;
return conv;
}
/* [conv.ptr]
A null pointer constant can be converted to a pointer type; ... A
null pointer constant of integral type can be converted to an
rvalue of type std::nullptr_t. */
if ((tcode == POINTER_TYPE || TYPE_PTRMEM_P (to)
|| NULLPTR_TYPE_P (to))
&& ((expr && null_ptr_cst_p (expr))
|| NULLPTR_TYPE_P (from)))
conv = build_conv (ck_std, to, conv);
else if ((tcode == INTEGER_TYPE && fcode == POINTER_TYPE)
|| (tcode == POINTER_TYPE && fcode == INTEGER_TYPE))
{
/* For backwards brain damage compatibility, allow interconversion of
pointers and integers with a pedwarn. */
conv = build_conv (ck_std, to, conv);
conv->bad_p = true;
}
else if (UNSCOPED_ENUM_P (to) && fcode == INTEGER_TYPE)
{
/* For backwards brain damage compatibility, allow interconversion of
enums and integers with a pedwarn. */
conv = build_conv (ck_std, to, conv);
conv->bad_p = true;
}
else if ((tcode == POINTER_TYPE && fcode == POINTER_TYPE)
|| (TYPE_PTRDATAMEM_P (to) && TYPE_PTRDATAMEM_P (from)))
{
tree to_pointee;
tree from_pointee;
if (tcode == POINTER_TYPE)
{
to_pointee = TREE_TYPE (to);
from_pointee = TREE_TYPE (from);
/* Since this is the target of a pointer, it can't have function
qualifiers, so any TYPE_QUALS must be for attributes const or
noreturn. Strip them. */
if (TREE_CODE (to_pointee) == FUNCTION_TYPE
&& TYPE_QUALS (to_pointee))
to_pointee = build_qualified_type (to_pointee, TYPE_UNQUALIFIED);
if (TREE_CODE (from_pointee) == FUNCTION_TYPE
&& TYPE_QUALS (from_pointee))
from_pointee = build_qualified_type (from_pointee, TYPE_UNQUALIFIED);
}
else
{
to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to);
from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from);
}
if (tcode == POINTER_TYPE
&& same_type_ignoring_top_level_qualifiers_p (from_pointee,
to_pointee))
;
else if (VOID_TYPE_P (to_pointee)
&& !TYPE_PTRDATAMEM_P (from)
&& TREE_CODE (from_pointee) != FUNCTION_TYPE)
{
tree nfrom = TREE_TYPE (from);
/* Don't try to apply restrict to void. */
int quals = cp_type_quals (nfrom) & ~TYPE_QUAL_RESTRICT;
from_pointee = cp_build_qualified_type (void_type_node, quals);
from = build_pointer_type (from_pointee);
conv = build_conv (ck_ptr, from, conv);
}
else if (TYPE_PTRDATAMEM_P (from))
{
tree fbase = TYPE_PTRMEM_CLASS_TYPE (from);
tree tbase = TYPE_PTRMEM_CLASS_TYPE (to);
if (same_type_p (fbase, tbase))
/* No base conversion needed. */;
else if (DERIVED_FROM_P (fbase, tbase)
&& (same_type_ignoring_top_level_qualifiers_p
(from_pointee, to_pointee)))
{
from = build_ptrmem_type (tbase, from_pointee);
conv = build_conv (ck_pmem, from, conv);
}
else
return NULL;
}
else if (CLASS_TYPE_P (from_pointee)
&& CLASS_TYPE_P (to_pointee)
/* [conv.ptr]
An rvalue of type "pointer to cv D," where D is a
class type, can be converted to an rvalue of type
"pointer to cv B," where B is a base class (clause
_class.derived_) of D. If B is an inaccessible
(clause _class.access_) or ambiguous
(_class.member.lookup_) base class of D, a program
that necessitates this conversion is ill-formed.
Therefore, we use DERIVED_FROM_P, and do not check
access or uniqueness. */
&& DERIVED_FROM_P (to_pointee, from_pointee))
{
from_pointee
= cp_build_qualified_type (to_pointee,
cp_type_quals (from_pointee));
from = build_pointer_type (from_pointee);
conv = build_conv (ck_ptr, from, conv);
conv->base_p = true;
}
if (same_type_p (from, to))
/* OK */;
else if (c_cast_p && comp_ptr_ttypes_const (to, from, bounds_either))
/* In a C-style cast, we ignore CV-qualification because we
are allowed to perform a static_cast followed by a
const_cast. */
conv = build_conv (ck_qual, to, conv);
else if (!c_cast_p && comp_ptr_ttypes (to_pointee, from_pointee))
conv = build_conv (ck_qual, to, conv);
else if (expr && string_conv_p (to, expr, 0))
/* converting from string constant to char *. */
conv = build_conv (ck_qual, to, conv);
else if (fnptr_conv_p (to, from))
conv = build_conv (ck_fnptr, to, conv);
/* Allow conversions among compatible ObjC pointer types (base
conversions have been already handled above). */
else if (c_dialect_objc ()
&& objc_compare_types (to, from, -4, NULL_TREE))
conv = build_conv (ck_ptr, to, conv);
else if (ptr_reasonably_similar (to_pointee, from_pointee))
{
conv = build_conv (ck_ptr, to, conv);
conv->bad_p = true;
}
else
return NULL;
from = to;
}
else if (TYPE_PTRMEMFUNC_P (to) && TYPE_PTRMEMFUNC_P (from))
{
tree fromfn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (from));
tree tofn = TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (to));
tree fbase = class_of_this_parm (fromfn);
tree tbase = class_of_this_parm (tofn);
/* If FBASE and TBASE are equivalent but incomplete, DERIVED_FROM_P
yields false. But a pointer to member of incomplete class is OK. */
if (!same_type_p (fbase, tbase) && !DERIVED_FROM_P (fbase, tbase))
return NULL;
tree fstat = static_fn_type (fromfn);
tree tstat = static_fn_type (tofn);
if (same_type_p (tstat, fstat)
|| fnptr_conv_p (tstat, fstat))
/* OK */;
else
return NULL;
if (!same_type_p (fbase, tbase))
{
from = build_memfn_type (fstat,
tbase,
cp_type_quals (tbase),
type_memfn_rqual (tofn));
from = build_ptrmemfunc_type (build_pointer_type (from));
conv = build_conv (ck_pmem, from, conv);
conv->base_p = true;
}
if (fnptr_conv_p (tstat, fstat))
conv = build_conv (ck_fnptr, to, conv);
}
else if (tcode == BOOLEAN_TYPE)
{
/* [conv.bool]
A prvalue of arithmetic, unscoped enumeration, pointer, or pointer
to member type can be converted to a prvalue of type bool. ...
For direct-initialization (8.5 [dcl.init]), a prvalue of type
std::nullptr_t can be converted to a prvalue of type bool; */
if (ARITHMETIC_TYPE_P (from)
|| UNSCOPED_ENUM_P (from)
|| fcode == POINTER_TYPE
|| TYPE_PTRMEM_P (from)
|| NULLPTR_TYPE_P (from))
{
conv = build_conv (ck_std, to, conv);
if (fcode == POINTER_TYPE
|| TYPE_PTRDATAMEM_P (from)
|| (TYPE_PTRMEMFUNC_P (from)
&& conv->rank < cr_pbool)
|| NULLPTR_TYPE_P (from))
conv->rank = cr_pbool;
if (NULLPTR_TYPE_P (from) && (flags & LOOKUP_ONLYCONVERTING))
conv->bad_p = true;
if (flags & LOOKUP_NO_NARROWING)
conv->check_narrowing = true;
return conv;
}
return NULL;
}
/* We don't check for ENUMERAL_TYPE here because there are no standard
conversions to enum type. */
/* As an extension, allow conversion to complex type. */
else if (ARITHMETIC_TYPE_P (to))
{
if (! (INTEGRAL_CODE_P (fcode)
|| (fcode == REAL_TYPE && !(flags & LOOKUP_NO_NON_INTEGRAL)))
|| SCOPED_ENUM_P (from))
return NULL;
/* If we're parsing an enum with no fixed underlying type, we're
dealing with an incomplete type, which renders the conversion
ill-formed. */
if (!COMPLETE_TYPE_P (from))
return NULL;
conv = build_conv (ck_std, to, conv);
tree underlying_type = NULL_TREE;
if (TREE_CODE (from) == ENUMERAL_TYPE
&& ENUM_FIXED_UNDERLYING_TYPE_P (from))
underlying_type = ENUM_UNDERLYING_TYPE (from);
/* Give this a better rank if it's a promotion.
To handle CWG 1601, also bump the rank if we are converting
an enumeration with a fixed underlying type to the underlying
type. */
if ((same_type_p (to, type_promotes_to (from))
|| (underlying_type && same_type_p (to, underlying_type)))
&& next_conversion (conv)->rank <= cr_promotion)
conv->rank = cr_promotion;
}
else if (fcode == VECTOR_TYPE && tcode == VECTOR_TYPE
&& vector_types_convertible_p (from, to, false))
return build_conv (ck_std, to, conv);
else if (MAYBE_CLASS_TYPE_P (to) && MAYBE_CLASS_TYPE_P (from)
&& is_properly_derived_from (from, to))
{
if (conv->kind == ck_rvalue)
conv = next_conversion (conv);
conv = build_conv (ck_base, to, conv);
/* The derived-to-base conversion indicates the initialization
of a parameter with base type from an object of a derived
type. A temporary object is created to hold the result of
the conversion unless we're binding directly to a reference. */
conv->need_temporary_p = !(flags & LOOKUP_NO_TEMP_BIND);
if (flags & LOOKUP_PREFER_RVALUE)
/* Tell convert_like to set LOOKUP_PREFER_RVALUE. */
conv->rvaluedness_matches_p = true;
/* If we're performing copy-initialization, remember to skip
explicit constructors. */
if (flags & LOOKUP_ONLYCONVERTING)
conv->copy_init_p = true;
}
else
return NULL;
if (flags & LOOKUP_NO_NARROWING)
conv->check_narrowing = true;
return conv;
}
/* Returns nonzero if T1 is reference-related to T2. */
bool
reference_related_p (tree t1, tree t2)
{
if (t1 == error_mark_node || t2 == error_mark_node)
return false;
t1 = TYPE_MAIN_VARIANT (t1);
t2 = TYPE_MAIN_VARIANT (t2);
/* [dcl.init.ref]
Given types "cv1 T1" and "cv2 T2," "cv1 T1" is reference-related
to "cv2 T2" if T1 is similar to T2, or T1 is a base class of T2. */
return (similar_type_p (t1, t2)
|| (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2)
&& DERIVED_FROM_P (t1, t2)));
}
/* Returns nonzero if T1 is reference-compatible with T2. */
bool
reference_compatible_p (tree t1, tree t2)
{
/* [dcl.init.ref]
"cv1 T1" is reference compatible with "cv2 T2" if
a prvalue of type "pointer to cv2 T2" can be converted to the type
"pointer to cv1 T1" via a standard conversion sequence. */
tree ptype1 = build_pointer_type (t1);
tree ptype2 = build_pointer_type (t2);
conversion *conv = standard_conversion (ptype1, ptype2, NULL_TREE,
/*c_cast_p=*/false, 0, tf_none);
if (!conv || conv->bad_p)
return false;
return true;
}
/* Return true if converting FROM to TO would involve a qualification
conversion. */
static bool
involves_qualification_conversion_p (tree to, tree from)
{
/* If we're not convering a pointer to another one, we won't get
a qualification conversion. */
if (!((TYPE_PTR_P (to) && TYPE_PTR_P (from))
|| (TYPE_PTRDATAMEM_P (to) && TYPE_PTRDATAMEM_P (from))))
return false;
conversion *conv = standard_conversion (to, from, NULL_TREE,
/*c_cast_p=*/false, 0, tf_none);
for (conversion *t = conv; t; t = next_conversion (t))
if (t->kind == ck_qual)
return true;
return false;
}
/* A reference of the indicated TYPE is being bound directly to the
expression represented by the implicit conversion sequence CONV.
Return a conversion sequence for this binding. */
static conversion *
direct_reference_binding (tree type, conversion *conv)
{
tree t;
gcc_assert (TYPE_REF_P (type));
gcc_assert (!TYPE_REF_P (conv->type));
t = TREE_TYPE (type);
if (conv->kind == ck_identity)
/* Mark the identity conv as to not decay to rvalue. */
conv->rvaluedness_matches_p = true;
/* [over.ics.rank]
When a parameter of reference type binds directly
(_dcl.init.ref_) to an argument expression, the implicit
conversion sequence is the identity conversion, unless the
argument expression has a type that is a derived class of the
parameter type, in which case the implicit conversion sequence is
a derived-to-base Conversion.
If the parameter binds directly to the result of applying a
conversion function to the argument expression, the implicit
conversion sequence is a user-defined conversion sequence
(_over.ics.user_), with the second standard conversion sequence
either an identity conversion or, if the conversion function
returns an entity of a type that is a derived class of the
parameter type, a derived-to-base conversion. */
if (is_properly_derived_from (conv->type, t))
{
/* Represent the derived-to-base conversion. */
conv = build_conv (ck_base, t, conv);
/* We will actually be binding to the base-class subobject in
the derived class, so we mark this conversion appropriately.
That way, convert_like knows not to generate a temporary. */
conv->need_temporary_p = false;
}
else if (involves_qualification_conversion_p (t, conv->type))
/* Represent the qualification conversion. After DR 2352
#1 and #2 were indistinguishable conversion sequences:
void f(int*); // #1
void f(const int* const &); // #2
void g(int* p) { f(p); }
because the types "int *" and "const int *const" are
reference-related and we were binding both directly and they
had the same rank. To break it up, we add a ck_qual under the
ck_ref_bind so that conversion sequence ranking chooses #1. */
conv = build_conv (ck_qual, t, conv);
return build_conv (ck_ref_bind, type, conv);
}
/* Returns the conversion path from type FROM to reference type TO for
purposes of reference binding. For lvalue binding, either pass a
reference type to FROM or an lvalue expression to EXPR. If the
reference will be bound to a temporary, NEED_TEMPORARY_P is set for
the conversion returned. If C_CAST_P is true, this
conversion is coming from a C-style cast. */
static conversion *
reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags,
tsubst_flags_t complain)
{
conversion *conv = NULL;
tree to = TREE_TYPE (rto);
tree from = rfrom;
tree tfrom;
bool related_p;
bool compatible_p;
cp_lvalue_kind gl_kind;
bool is_lvalue;
if (TREE_CODE (to) == FUNCTION_TYPE && expr && type_unknown_p (expr))
{
expr = instantiate_type (to, expr, tf_none);
if (expr == error_mark_node)
return NULL;
from = TREE_TYPE (expr);
}
bool copy_list_init = false;
if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
{
maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
/* DR 1288: Otherwise, if the initializer list has a single element
of type E and ... [T's] referenced type is reference-related to E,
the object or reference is initialized from that element...
??? With P0388R4, we should bind 't' directly to U{}:
using U = A[2];
A (&&t)[] = {U{}};
because A[] and A[2] are reference-related. But we don't do it
because grok_reference_init has deduced the array size (to 1), and
A[1] and A[2] aren't reference-related. */
if (CONSTRUCTOR_NELTS (expr) == 1
&& !CONSTRUCTOR_IS_DESIGNATED_INIT (expr))
{
tree elt = CONSTRUCTOR_ELT (expr, 0)->value;
if (error_operand_p (elt))
return NULL;
tree etype = TREE_TYPE (elt);
if (reference_related_p (to, etype))
{
expr = elt;
from = etype;
goto skip;
}
}
/* Otherwise, if T is a reference type, a prvalue temporary of the type
referenced by T is copy-list-initialized, and the reference is bound
to that temporary. */
copy_list_init = true;
skip:;
}
if (TYPE_REF_P (from))
{
from = TREE_TYPE (from);
if (!TYPE_REF_IS_RVALUE (rfrom)
|| TREE_CODE (from) == FUNCTION_TYPE)
gl_kind = clk_ordinary;
else
gl_kind = clk_rvalueref;
}
else if (expr)
gl_kind = lvalue_kind (expr);
else if (CLASS_TYPE_P (from)
|| TREE_CODE (from) == ARRAY_TYPE)
gl_kind = clk_class;
else
gl_kind = clk_none;
/* Don't allow a class prvalue when LOOKUP_NO_TEMP_BIND. */
if ((flags & LOOKUP_NO_TEMP_BIND)
&& (gl_kind & clk_class))
gl_kind = clk_none;
/* Same mask as real_lvalue_p. */
is_lvalue = gl_kind && !(gl_kind & (clk_rvalueref|clk_class));
tfrom = from;
if ((gl_kind & clk_bitfield) != 0)
tfrom = unlowered_expr_type (expr);
/* Figure out whether or not the types are reference-related and
reference compatible. We have to do this after stripping
references from FROM. */
related_p = reference_related_p (to, tfrom);
/* If this is a C cast, first convert to an appropriately qualified
type, so that we can later do a const_cast to the desired type. */
if (related_p && c_cast_p
&& !at_least_as_qualified_p (to, tfrom))
to = cp_build_qualified_type (to, cp_type_quals (tfrom));
compatible_p = reference_compatible_p (to, tfrom);
/* Directly bind reference when target expression's type is compatible with
the reference and expression is an lvalue. In DR391, the wording in
[8.5.3/5 dcl.init.ref] is changed to also require direct bindings for
const and rvalue references to rvalues of compatible class type.
We should also do direct bindings for non-class xvalues. */
if ((related_p || compatible_p) && gl_kind)
{
/* [dcl.init.ref]
If the initializer expression
-- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
is reference-compatible with "cv2 T2,"
the reference is bound directly to the initializer expression
lvalue.
[...]
If the initializer expression is an rvalue, with T2 a class type,
and "cv1 T1" is reference-compatible with "cv2 T2", the reference
is bound to the object represented by the rvalue or to a sub-object
within that object. */
conv = build_identity_conv (tfrom, expr);
conv = direct_reference_binding (rto, conv);
if (TYPE_REF_P (rfrom))
/* Handle rvalue reference to function properly. */
conv->rvaluedness_matches_p
= (TYPE_REF_IS_RVALUE (rto) == TYPE_REF_IS_RVALUE (rfrom));
else
conv->rvaluedness_matches_p
= (TYPE_REF_IS_RVALUE (rto) == !is_lvalue);
if ((gl_kind & clk_bitfield) != 0
|| ((gl_kind & clk_packed) != 0 && !TYPE_PACKED (to)))
/* For the purposes of overload resolution, we ignore the fact
this expression is a bitfield or packed field. (In particular,
[over.ics.ref] says specifically that a function with a
non-const reference parameter is viable even if the
argument is a bitfield.)
However, when we actually call the function we must create
a temporary to which to bind the reference. If the
reference is volatile, or isn't const, then we cannot make
a temporary, so we just issue an error when the conversion
actually occurs. */
conv->need_temporary_p = true;
/* Don't allow binding of lvalues (other than function lvalues) to
rvalue references. */
if (is_lvalue && TYPE_REF_IS_RVALUE (rto)
&& TREE_CODE (to) != FUNCTION_TYPE)
conv->bad_p = true;
/* Nor the reverse. */
if (!is_lvalue && !TYPE_REF_IS_RVALUE (rto)
/* Unless it's really an lvalue. */
&& !(cxx_dialect >= cxx20
&& (gl_kind & clk_implicit_rval))
&& (!CP_TYPE_CONST_NON_VOLATILE_P (to)
|| (flags & LOOKUP_NO_RVAL_BIND))
&& TREE_CODE (to) != FUNCTION_TYPE)
conv->bad_p = true;
if (!compatible_p)
conv->bad_p = true;
return conv;
}
/* [class.conv.fct] A conversion function is never used to convert a
(possibly cv-qualified) object to the (possibly cv-qualified) same
object type (or a reference to it), to a (possibly cv-qualified) base
class of that type (or a reference to it).... */
else if (CLASS_TYPE_P (from) && !related_p
&& !(flags & LOOKUP_NO_CONVERSION))
{
/* [dcl.init.ref]
If the initializer expression
-- has a class type (i.e., T2 is a class type) can be
implicitly converted to an lvalue of type "cv3 T3," where
"cv1 T1" is reference-compatible with "cv3 T3". (this
conversion is selected by enumerating the applicable
conversion functions (_over.match.ref_) and choosing the
best one through overload resolution. (_over.match_).
the reference is bound to the lvalue result of the conversion
in the second case. */
z_candidate *cand = build_user_type_conversion_1 (rto, expr, flags,
complain);
if (cand)
return cand->second_conv;
}
/* From this point on, we conceptually need temporaries, even if we
elide them. Only the cases above are "direct bindings". */
if (flags & LOOKUP_NO_TEMP_BIND)
return NULL;
/* [over.ics.rank]
When a parameter of reference type is not bound directly to an
argument expression, the conversion sequence is the one required
to convert the argument expression to the underlying type of the
reference according to _over.best.ics_. Conceptually, this
conversion sequence corresponds to copy-initializing a temporary
of the underlying type with the argument expression. Any
difference in top-level cv-qualification is subsumed by the
initialization itself and does not constitute a conversion. */
/* [dcl.init.ref]
Otherwise, the reference shall be an lvalue reference to a
non-volatile const type, or the reference shall be an rvalue
reference.
We try below to treat this as a bad conversion to improve diagnostics,
but if TO is an incomplete class, we need to reject this conversion
now to avoid unnecessary instantiation. */
if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto)
&& !COMPLETE_TYPE_P (to))
return NULL;
/* We're generating a temporary now, but don't bind any more in the
conversion (specifically, don't slice the temporary returned by a
conversion operator). */
flags |= LOOKUP_NO_TEMP_BIND;
/* Core issue 899: When [copy-]initializing a temporary to be bound
to the first parameter of a copy constructor (12.8) called with
a single argument in the context of direct-initialization,
explicit conversion functions are also considered.
So don't set LOOKUP_ONLYCONVERTING in that case. */
if (!(flags & LOOKUP_COPY_PARM))
flags |= LOOKUP_ONLYCONVERTING;
if (!conv)
conv = implicit_conversion (to, from, expr, c_cast_p,
flags, complain);
if (!conv)
return NULL;
if (conv->user_conv_p)
{
if (copy_list_init)
/* Remember this was copy-list-initialization. */
conv->need_temporary_p = true;
/* If initializing the temporary used a conversion function,
recalculate the second conversion sequence. */
for (conversion *t = conv; t; t = next_conversion (t))
if (t->kind == ck_user
&& DECL_CONV_FN_P (t->cand->fn))
{
tree ftype = TREE_TYPE (TREE_TYPE (t->cand->fn));
/* A prvalue of non-class type is cv-unqualified. */
if (!TYPE_REF_P (ftype) && !CLASS_TYPE_P (ftype))
ftype = cv_unqualified (ftype);
int sflags = (flags|LOOKUP_NO_CONVERSION)&~LOOKUP_NO_TEMP_BIND;
conversion *new_second
= reference_binding (rto, ftype, NULL_TREE, c_cast_p,
sflags, complain);
if (!new_second)
return NULL;
return merge_conversion_sequences (t, new_second);
}
}
conv = build_conv (ck_ref_bind, rto, conv);
/* This reference binding, unlike those above, requires the
creation of a temporary. */
conv->need_temporary_p = true;
conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
/* [dcl.init.ref]
Otherwise, the reference shall be an lvalue reference to a
non-volatile const type, or the reference shall be an rvalue
reference. */
if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto))
conv->bad_p = true;
/* [dcl.init.ref]
Otherwise, a temporary of type "cv1 T1" is created and
initialized from the initializer expression using the rules for a
non-reference copy initialization. If T1 is reference-related to
T2, cv1 must be the same cv-qualification as, or greater
cv-qualification than, cv2; otherwise, the program is ill-formed. */
if (related_p && !at_least_as_qualified_p (to, from))
conv->bad_p = true;
return conv;
}
/* Most of the implementation of implicit_conversion, with the same
parameters. */
static conversion *
implicit_conversion_1 (tree to, tree from, tree expr, bool c_cast_p,
int flags, tsubst_flags_t complain)
{
conversion *conv;
if (from == error_mark_node || to == error_mark_node
|| expr == error_mark_node)
return NULL;
/* Other flags only apply to the primary function in overload
resolution, or after we've chosen one. */
flags &= (LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION|LOOKUP_COPY_PARM
|LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND|LOOKUP_PREFER_RVALUE
|LOOKUP_NO_NARROWING|LOOKUP_PROTECT|LOOKUP_NO_NON_INTEGRAL);
/* FIXME: actually we don't want warnings either, but we can't just
have 'complain &= ~(tf_warning|tf_error)' because it would cause
the regression of, eg, g++.old-deja/g++.benjamin/16077.C.
We really ought not to issue that warning until we've committed
to that conversion. */
complain &= ~tf_error;
/* Call reshape_init early to remove redundant braces. */
if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr)
&& CLASS_TYPE_P (to)
&& COMPLETE_TYPE_P (complete_type (to))
&& !CLASSTYPE_NON_AGGREGATE (to))
{
expr = reshape_init (to, expr, complain);
if (expr == error_mark_node)
return NULL;
from = TREE_TYPE (expr);
}
if (TYPE_REF_P (to))
conv = reference_binding (to, from, expr, c_cast_p, flags, complain);
else
conv = standard_conversion (to, from, expr, c_cast_p, flags, complain);
if (conv)
return conv;
if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr))
{
if (is_std_init_list (to) && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr))
return build_list_conv (to, expr, flags, complain);
/* As an extension, allow list-initialization of _Complex. */
if (TREE_CODE (to) == COMPLEX_TYPE
&& !CONSTRUCTOR_IS_DESIGNATED_INIT (expr))
{
conv = build_complex_conv (to, expr, flags, complain);
if (conv)
return conv;
}
/* Allow conversion from an initializer-list with one element to a
scalar type. */
if (SCALAR_TYPE_P (to))
{
int nelts = CONSTRUCTOR_NELTS (expr);
tree elt;
if (nelts == 0)
elt = build_value_init (to, tf_none);
else if (nelts == 1 && !CONSTRUCTOR_IS_DESIGNATED_INIT (expr))
elt = CONSTRUCTOR_ELT (expr, 0)->value;
else
elt = error_mark_node;
conv = implicit_conversion (to, TREE_TYPE (elt), elt,
c_cast_p, flags, complain);
if (conv)
{
conv->check_narrowing = true;
if (BRACE_ENCLOSED_INITIALIZER_P (elt))
/* Too many levels of braces, i.e. '{{1}}'. */
conv->bad_p = true;
return conv;
}
}
else if (TREE_CODE (to) == ARRAY_TYPE)
return build_array_conv (to, expr, flags, complain);
}
if (expr != NULL_TREE
&& (MAYBE_CLASS_TYPE_P (from)
|| MAYBE_CLASS_TYPE_P (to))
&& (flags & LOOKUP_NO_CONVERSION) == 0)
{
struct z_candidate *cand;
if (CLASS_TYPE_P (to)
&& BRACE_ENCLOSED_INITIALIZER_P (expr)
&& !CLASSTYPE_NON_AGGREGATE (complete_type (to)))
return build_aggr_conv (to, expr, flags, complain);
cand = build_user_type_conversion_1 (to, expr, flags, complain);
if (cand)
{
if (BRACE_ENCLOSED_INITIALIZER_P (expr)
&& CONSTRUCTOR_NELTS (expr) == 1
&& !CONSTRUCTOR_IS_DESIGNATED_INIT (expr)
&& !is_list_ctor (cand->fn))
{
/* "If C is not an initializer-list constructor and the
initializer list has a single element of type cv U, where U is
X or a class derived from X, the implicit conversion sequence
has Exact Match rank if U is X, or Conversion rank if U is
derived from X." */
tree elt = CONSTRUCTOR_ELT (expr, 0)->value;
tree elttype = TREE_TYPE (elt);
if (reference_related_p (to, elttype))
return implicit_conversion (to, elttype, elt,
c_cast_p, flags, complain);
}
conv = cand->second_conv;
}
/* We used to try to bind a reference to a temporary here, but that
is now handled after the recursive call to this function at the end
of reference_binding. */
return conv;
}
return NULL;
}
/* Returns the implicit conversion sequence (see [over.ics]) from type
FROM to type TO. The optional expression EXPR may affect the
conversion. FLAGS are the usual overloading flags. If C_CAST_P is
true, this conversion is coming from a C-style cast. */
static conversion *
implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
int flags, tsubst_flags_t complain)
{
conversion *conv = implicit_conversion_1 (to, from, expr, c_cast_p,
flags, complain);
if (!conv || conv->bad_p)
return conv;
if (conv_is_prvalue (conv)
&& CLASS_TYPE_P (conv->type)
&& CLASSTYPE_PURE_VIRTUALS (conv->type))
conv->bad_p = true;
return conv;
}
/* Like implicit_conversion, but return NULL if the conversion is bad.
This is not static so that check_non_deducible_conversion can call it within
add_template_candidate_real as part of overload resolution; it should not be
called outside of overload resolution. */
conversion *
good_conversion (tree to, tree from, tree expr,
int flags, tsubst_flags_t complain)
{
conversion *c = implicit_conversion (to, from, expr, /*cast*/false,
flags, complain);
if (c && c->bad_p)
c = NULL;
return c;
}
/* Add a new entry to the list of candidates. Used by the add_*_candidate
functions. ARGS will not be changed until a single candidate is
selected. */
static struct z_candidate *
add_candidate (struct z_candidate **candidates,
tree fn, tree first_arg, const vec<tree, va_gc> *args,
size_t num_convs, conversion **convs,
tree access_path, tree conversion_path,
int viable, struct rejection_reason *reason,
int flags)
{
struct z_candidate *cand = (struct z_candidate *)
conversion_obstack_alloc (sizeof (struct z_candidate));
cand->fn = fn;
cand->first_arg = first_arg;
cand->args = args;
cand->convs = convs;
cand->num_convs = num_convs;
cand->access_path = access_path;
cand->conversion_path = conversion_path;
cand->viable = viable;
cand->reason = reason;
cand->next = *candidates;
cand->flags = flags;
*candidates = cand;
if (convs && cand->reversed ())
/* Swap the conversions for comparison in joust; we'll swap them back
before build_over_call. */
std::swap (convs[0], convs[1]);
return cand;
}
/* Return the number of remaining arguments in the parameter list
beginning with ARG. */
int
remaining_arguments (tree arg)
{
int n;
for (n = 0; arg != NULL_TREE && arg != void_list_node;
arg = TREE_CHAIN (arg))
n++;
return n;
}
/* [over.match.copy]: When initializing a temporary object (12.2) to be bound
to the first parameter of a constructor where the parameter is of type
"reference to possibly cv-qualified T" and the constructor is called with a
single argument in the context of direct-initialization of an object of type
"cv2 T", explicit conversion functions are also considered.
So set LOOKUP_COPY_PARM to let reference_binding know that
it's being called in that context. */
int
conv_flags (int i, int nargs, tree fn, tree arg, int flags)
{
int lflags = flags;
tree t;
if (i == 0 && nargs == 1 && DECL_CONSTRUCTOR_P (fn)
&& (t = FUNCTION_FIRST_USER_PARMTYPE (fn))
&& (same_type_ignoring_top_level_qualifiers_p
(non_reference (TREE_VALUE (t)), DECL_CONTEXT (fn))))
{
if (!(flags & LOOKUP_ONLYCONVERTING))
lflags |= LOOKUP_COPY_PARM;
if ((flags & LOOKUP_LIST_INIT_CTOR)
&& BRACE_ENCLOSED_INITIALIZER_P (arg))
lflags |= LOOKUP_NO_CONVERSION;
}
else
lflags |= LOOKUP_ONLYCONVERTING;
return lflags;
}
/* Build an appropriate 'this' conversion for the method FN and class
type CTYPE from the value ARG (having type ARGTYPE) to the type PARMTYPE.
This function modifies PARMTYPE, ARGTYPE and ARG. */
static conversion *
build_this_conversion (tree fn, tree ctype,
tree& parmtype, tree& argtype, tree& arg,
int flags, tsubst_flags_t complain)
{
gcc_assert (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
&& !DECL_CONSTRUCTOR_P (fn));
/* The type of the implicit object parameter ('this') for
overload resolution is not always the same as for the
function itself; conversion functions are considered to
be members of the class being converted, and functions
introduced by a using-declaration are considered to be
members of the class that uses them.
Since build_over_call ignores the ICS for the `this'
parameter, we can just change the parm type. */
parmtype = cp_build_qualified_type (ctype,
cp_type_quals (TREE_TYPE (parmtype)));
bool this_p = true;
if (FUNCTION_REF_QUALIFIED (TREE_TYPE (fn)))
{
/* If the function has a ref-qualifier, the implicit
object parameter has reference type. */
bool rv = FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (fn));
parmtype = cp_build_reference_type (parmtype, rv);
/* The special handling of 'this' conversions in compare_ics
does not apply if there is a ref-qualifier. */
this_p = false;
}
else
{
parmtype = build_pointer_type (parmtype);
/* We don't use build_this here because we don't want to
capture the object argument until we've chosen a
non-static member function. */
arg = build_address (arg);
argtype = lvalue_type (arg);
}
flags |= LOOKUP_ONLYCONVERTING;
conversion *t = implicit_conversion (parmtype, argtype, arg,
/*c_cast_p=*/false, flags, complain);
t->this_p = this_p;
return t;
}
/* Create an overload candidate for the function or method FN called
with the argument list FIRST_ARG/ARGS and add it to CANDIDATES.
FLAGS is passed on to implicit_conversion.
This does not change ARGS.
CTYPE, if non-NULL, is the type we want to pretend this function
comes from for purposes of overload resolution.
SHORTCUT_BAD_CONVS controls how we handle "bad" argument conversions.
If true, we stop computing conversions upon seeing the first bad
conversion. This is used by add_candidates to avoid computing
more conversions than necessary in the presence of a strictly viable
candidate, while preserving the defacto behavior of overload resolution
when it turns out there are only non-strictly viable candidates. */
static struct z_candidate *
add_function_candidate (struct z_candidate **candidates,
tree fn, tree ctype, tree first_arg,
const vec<tree, va_gc> *args, tree access_path,
tree conversion_path, int flags,
conversion **convs,
bool shortcut_bad_convs,
tsubst_flags_t complain)
{
tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn));
int i, len;
tree parmnode;
tree orig_first_arg = first_arg;
int skip;
int viable = 1;
struct rejection_reason *reason = NULL;
/* The `this', `in_chrg' and VTT arguments to constructors are not
considered in overload resolution. */
if (DECL_CONSTRUCTOR_P (fn))
{
if (ctor_omit_inherited_parms (fn))
/* Bring back parameters omitted from an inherited ctor. */
parmlist = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (fn));
else
parmlist = skip_artificial_parms_for (fn, parmlist);
skip = num_artificial_parms_for (fn);
if (skip > 0 && first_arg != NULL_TREE)
{
--skip;
first_arg = NULL_TREE;
}
}
else
skip = 0;
len = vec_safe_length (args) - skip + (first_arg != NULL_TREE ? 1 : 0);
if (!convs)
convs = alloc_conversions (len);
/* 13.3.2 - Viable functions [over.match.viable]
First, to be a viable function, a candidate function shall have enough
parameters to agree in number with the arguments in the list.
We need to check this first; otherwise, checking the ICSes might cause
us to produce an ill-formed template instantiation. */
parmnode = parmlist;
for (i = 0; i < len; ++i)
{
if (parmnode == NULL_TREE || parmnode == void_list_node)
break;
parmnode = TREE_CHAIN (parmnode);
}
if ((i < len && parmnode)
|| !sufficient_parms_p (parmnode))
{
int remaining = remaining_arguments (parmnode);
viable = 0;
reason = arity_rejection (first_arg, i + remaining, len);
}
/* An inherited constructor (12.6.3 [class.inhctor.init]) that has a first
parameter of type "reference to cv C" (including such a constructor
instantiated from a template) is excluded from the set of candidate
functions when used to construct an object of type D with an argument list
containing a single argument if C is reference-related to D. */
if (viable && len == 1 && parmlist && DECL_CONSTRUCTOR_P (fn)
&& flag_new_inheriting_ctors
&& DECL_INHERITED_CTOR (fn))
{
tree ptype = non_reference (TREE_VALUE (parmlist));
tree dtype = DECL_CONTEXT (fn);
tree btype = DECL_INHERITED_CTOR_BASE (fn);
if (reference_related_p (ptype, dtype)
&& reference_related_p (btype, ptype))
{
viable = false;
reason = inherited_ctor_rejection ();
}
}
/* Second, for a function to be viable, its constraints must be
satisfied. */
if (flag_concepts && viable && !constraints_satisfied_p (fn))
{
reason = constraint_failure ();
viable = false;
}
/* When looking for a function from a subobject from an implicit
copy/move constructor/operator=, don't consider anything that takes (a
reference to) an unrelated type. See c++/44909 and core 1092. */
if (viable && parmlist && (flags & LOOKUP_DEFAULTED))
{
if (DECL_CONSTRUCTOR_P (fn))
i = 1;
else if (DECL_ASSIGNMENT_OPERATOR_P (fn)
&& DECL_OVERLOADED_OPERATOR_IS (fn, NOP_EXPR))
i = 2;
else
i = 0;
if (i && len == i)
{
parmnode = chain_index (i-1, parmlist);
if (!reference_related_p (non_reference (TREE_VALUE (parmnode)),
ctype))
viable = 0;
}
/* This only applies at the top level. */
flags &= ~LOOKUP_DEFAULTED;
}
if (! viable)
goto out;
/* Third, for F to be a viable function, there shall exist for each
argument an implicit conversion sequence that converts that argument
to the corresponding parameter of F. */
parmnode = parmlist;
for (i = 0; i < len; ++i)
{
tree argtype, to_type;
tree arg;
if (parmnode == void_list_node)
break;
if (convs[i])
{
/* Already set during deduction. */
parmnode = TREE_CHAIN (parmnode);
continue;
}
if (i == 0 && first_arg != NULL_TREE)
arg = first_arg;
else
arg = CONST_CAST_TREE (
(*args)[i + skip - (first_arg != NULL_TREE ? 1 : 0)]);
argtype = lvalue_type (arg);
conversion *t;
if (parmnode)
{
tree parmtype = TREE_VALUE (parmnode);
if (i == 0
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)
&& !DECL_CONSTRUCTOR_P (fn))
t = build_this_conversion (fn, ctype, parmtype, argtype, arg,
flags, complain);
else
{
int lflags = conv_flags (i, len-skip, fn, arg, flags);
t = implicit_conversion (parmtype, argtype, arg,
/*c_cast_p=*/false, lflags, complain);
}
to_type = parmtype;
parmnode = TREE_CHAIN (parmnode);
}
else
{
t = build_identity_conv (argtype, arg);
t->ellipsis_p = true;
to_type = argtype;
}
convs[i] = t;
if (! t)
{
viable = 0;
reason = arg_conversion_rejection (first_arg, i, argtype, to_type,
EXPR_LOCATION (arg));
break;
}
if (t->bad_p)
{
viable = -1;
reason = bad_arg_conversion_rejection (first_arg, i, arg, to_type,
EXPR_LOCATION (arg));
if (shortcut_bad_convs)
break;
}
}
out:
return add_candidate (candidates, fn, orig_first_arg, args, len, convs,
access_path, conversion_path, viable, reason, flags);
}
/* Create an overload candidate for the conversion function FN which will
be invoked for expression OBJ, producing a pointer-to-function which
will in turn be called with the argument list FIRST_ARG/ARGLIST,
and add it to CANDIDATES. This does not change ARGLIST. FLAGS is
passed on to implicit_conversion.
Actually, we don't really care about FN; we care about the type it
converts to. There may be multiple conversion functions that will
convert to that type, and we rely on build_user_type_conversion_1 to
choose the best one; so when we create our candidate, we record the type
instead of the function. */
static struct z_candidate *
add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj,
const vec<tree, va_gc> *arglist,
tree access_path, tree conversion_path,
tsubst_flags_t complain)
{
tree totype = TREE_TYPE (TREE_TYPE (fn));
int i, len, viable, flags;
tree parmlist, parmnode;
conversion **convs;
struct rejection_reason *reason;
for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; )
parmlist = TREE_TYPE (parmlist);
parmlist = TYPE_ARG_TYPES (parmlist);
len = vec_safe_length (arglist) + 1;
convs = alloc_conversions (len);
parmnode = parmlist;
viable = 1;
flags = LOOKUP_IMPLICIT;
reason = NULL;
/* Don't bother looking up the same type twice. */
if (*candidates && (*candidates)->fn == totype)
return NULL;
for (i = 0; i < len; ++i)
{
tree arg, argtype, convert_type = NULL_TREE;
conversion *t;
if (i == 0)
arg = obj;
else
arg = (*arglist)[i - 1];
argtype = lvalue_type (arg);
if (i == 0)
{
t = build_identity_conv (argtype, NULL_TREE);
t = build_conv (ck_user, totype, t);
/* Leave the 'cand' field null; we'll figure out the conversion in
convert_like if this candidate is chosen. */
convert_type = totype;
}
else if (parmnode == void_list_node)
break;
else if (parmnode)
{
t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg,
/*c_cast_p=*/false, flags, complain);
convert_type = TREE_VALUE (parmnode);
}
else
{
t = build_identity_conv (argtype, arg);
t->ellipsis_p = true;
convert_type = argtype;
}
convs[i] = t;
if (! t)
break;
if (t->bad_p)
{
viable = -1;
reason = bad_arg_conversion_rejection (NULL_TREE, i, arg, convert_type,
EXPR_LOCATION (arg));
}
if (i == 0)
continue;
if (parmnode)
parmnode = TREE_CHAIN (parmnode);
}
if (i < len
|| ! sufficient_parms_p (parmnode))
{
int remaining = remaining_arguments (parmnode);
viable = 0;
reason = arity_rejection (NULL_TREE, i + remaining, len);
}
return add_candidate (candidates, totype, obj, arglist, len, convs,
access_path, conversion_path, viable, reason, flags);
}
static void
build_builtin_candidate (struct z_candidate **candidates, tree fnname,
tree type1, tree type2, const vec<tree,va_gc> &args,
tree *argtypes, int flags, tsubst_flags_t complain)
{
conversion *t;
conversion **convs;
size_t num_convs;
int viable = 1;
tree types[2];
struct rejection_reason *reason = NULL;
types[0] = type1;
types[1] = type2;
num_convs = args.length ();
convs = alloc_conversions (num_convs);
/* TRUTH_*_EXPR do "contextual conversion to bool", which means explicit
conversion ops are allowed. We handle that here by just checking for
boolean_type_node because other operators don't ask for it. COND_EXPR
also does contextual conversion to bool for the first operand, but we
handle that in build_conditional_expr, and type1 here is operand 2. */
if (type1 != boolean_type_node)
flags |= LOOKUP_ONLYCONVERTING;
for (unsigned i = 0; i < 2 && i < num_convs; ++i)
{
t = implicit_conversion (types[i], argtypes[i], args[i],
/*c_cast_p=*/false, flags, complain);
if (! t)
{
viable = 0;
/* We need something for printing the candidate. */
t = build_identity_conv (types[i], NULL_TREE);
reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i],
types[i], EXPR_LOCATION (args[i]));
}
else if (t->bad_p)
{
viable = 0;
reason = bad_arg_conversion_rejection (NULL_TREE, i, args[i],
types[i],
EXPR_LOCATION (args[i]));
}
convs[i] = t;
}
/* For COND_EXPR we rearranged the arguments; undo that now. */
if (num_convs == 3)
{
convs[2] = convs[1];
convs[1] = convs[0];
t = implicit_conversion (boolean_type_node, argtypes[2], args[2],
/*c_cast_p=*/false, flags,
complain);
if (t)
convs[0] = t;
else
{
viable = 0;
reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2],
boolean_type_node,
EXPR_LOCATION (args[2]));
}
}
add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL,
num_convs, convs,
/*access_path=*/NULL_TREE,
/*conversion_path=*/NULL_TREE,
viable, reason, flags);
}
static bool
is_complete (tree t)
{
return COMPLETE_TYPE_P (complete_type (t));
}
/* Returns nonzero if TYPE is a promoted arithmetic type. */
static bool
promoted_arithmetic_type_p (tree type)
{
/* [over.built]
In this section, the term promoted integral type is used to refer
to those integral types which are preserved by integral promotion
(including e.g. int and long but excluding e.g. char).
Similarly, the term promoted arithmetic type refers to promoted
integral types plus floating types. */
return ((CP_INTEGRAL_TYPE_P (type)
&& same_type_p (type_promotes_to (type), type))
|| TREE_CODE (type) == REAL_TYPE);
}
/* Create any builtin operator overload candidates for the operator in
question given the converted operand types TYPE1 and TYPE2. The other
args are passed through from add_builtin_candidates to
build_builtin_candidate.
TYPE1 and TYPE2 may not be permissible, and we must filter them.
If CODE is requires candidates operands of the same type of the kind
of which TYPE1 and TYPE2 are, we add both candidates
CODE (TYPE1, TYPE1) and CODE (TYPE2, TYPE2). */
static void
add_builtin_candidate (struct z_candidate **candidates, enum tree_code code,
enum tree_code code2, tree fnname, tree type1,
tree type2, vec<tree,va_gc> &args, tree *argtypes,
int flags, tsubst_flags_t complain)
{
switch (code)
{
case POSTINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
args[1] = integer_zero_node;
type2 = integer_type_node;
break;
default:
break;
}
switch (code)
{
/* 4 For every pair (T, VQ), where T is an arithmetic type other than bool,
and VQ is either volatile or empty, there exist candidate operator
functions of the form
VQ T& operator++(VQ T&);
T operator++(VQ T&, int);
5 For every pair (T, VQ), where T is an arithmetic type other than bool,
and VQ is either volatile or empty, there exist candidate operator
functions of the form
VQ T& operator--(VQ T&);
T operator--(VQ T&, int);
6 For every pair (T, VQ), where T is a cv-qualified or cv-unqualified object
type, and VQ is either volatile or empty, there exist candidate operator
functions of the form
T*VQ& operator++(T*VQ&);
T*VQ& operator--(T*VQ&);
T* operator++(T*VQ&, int);
T* operator--(T*VQ&, int); */
case POSTDECREMENT_EXPR:
case PREDECREMENT_EXPR:
if (TREE_CODE (type1) == BOOLEAN_TYPE)
return;
/* FALLTHRU */
case POSTINCREMENT_EXPR:
case PREINCREMENT_EXPR:
/* P0002R1, Remove deprecated operator++(bool) added "other than bool"
to p4. */
if (TREE_CODE (type1) == BOOLEAN_TYPE && cxx_dialect >= cxx17)
return;
if (ARITHMETIC_TYPE_P (type1) || TYPE_PTROB_P (type1))
{
type1 = build_reference_type (type1);
break;
}
return;
/* 7 For every cv-qualified or cv-unqualified object type T, there
exist candidate operator functions of the form
T& operator*(T*);
8 For every function type T that does not have cv-qualifiers or
a ref-qualifier, there exist candidate operator functions of the form
T& operator*(T*); */
case INDIRECT_REF:
if (TYPE_PTR_P (type1)
&& (TYPE_PTROB_P (type1)
|| TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE))
break;
return;
/* 9 For every type T, there exist candidate operator functions of the form
T* operator+(T*);
10 For every floating-point or promoted integral type T, there exist
candidate operator functions of the form
T operator+(T);
T operator-(T); */
case UNARY_PLUS_EXPR: /* unary + */
if (TYPE_PTR_P (type1))
break;
/* FALLTHRU */
case NEGATE_EXPR:
if (ARITHMETIC_TYPE_P (type1))
break;
return;
/* 11 For every promoted integral type T, there exist candidate operator
functions of the form
T operator~(T); */
case BIT_NOT_EXPR:
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1))
break;
return;
/* 12 For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, C1
is the same type as C2 or is a derived class of C2, and T is an object
type or a function type there exist candidate operator functions of the
form
CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
where CV12 is the union of CV1 and CV2. */
case MEMBER_REF:
if (TYPE_PTR_P (type1) && TYPE_PTRMEM_P (type2))
{
tree c1 = TREE_TYPE (type1);
tree c2 = TYPE_PTRMEM_CLASS_TYPE (type2);
if (MAYBE_CLASS_TYPE_P (c1) && DERIVED_FROM_P (c2, c1)
&& (TYPE_PTRMEMFUNC_P (type2)
|| is_complete (TYPE_PTRMEM_POINTED_TO_TYPE (type2))))
break;
}
return;
/* 13 For every pair of types L and R, where each of L and R is a floating-point
or promoted integral type, there exist candidate operator functions of the
form
LR operator*(L, R);
LR operator/(L, R);
LR operator+(L, R);
LR operator-(L, R);
bool operator<(L, R);
bool operator>(L, R);
bool operator<=(L, R);
bool operator>=(L, R);
bool operator==(L, R);
bool operator!=(L, R);
where LR is the result of the usual arithmetic conversions between
types L and R.
14 For every integral type T there exists a candidate operator function of
the form
std::strong_ordering operator<=>(T, T);
15 For every pair of floating-point types L and R, there exists a candidate
operator function of the form
std::partial_ordering operator<=>(L, R);
16 For every cv-qualified or cv-unqualified object type T there exist
candidate operator functions of the form
T* operator+(T*, std::ptrdiff_t);
T& operator[](T*, std::ptrdiff_t);
T* operator-(T*, std::ptrdiff_t);
T* operator+(std::ptrdiff_t, T*);
T& operator[](std::ptrdiff_t, T*);
17 For every T, where T is a pointer to object type, there exist candidate
operator functions of the form
std::ptrdiff_t operator-(T, T);
18 For every T, where T is an enumeration type or a pointer type, there
exist candidate operator functions of the form
bool operator<(T, T);
bool operator>(T, T);
bool operator<=(T, T);
bool operator>=(T, T);
bool operator==(T, T);
bool operator!=(T, T);
R operator<=>(T, T);
where R is the result type specified in [expr.spaceship].
19 For every T, where T is a pointer-to-member type or std::nullptr_t,
there exist candidate operator functions of the form
bool operator==(T, T);
bool operator!=(T, T); */
case MINUS_EXPR:
if (TYPE_PTROB_P (type1) && TYPE_PTROB_P (type2))
break;
if (TYPE_PTROB_P (type1)
&& INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
{
type2 = ptrdiff_type_node;
break;
}
/* FALLTHRU */
case MULT_EXPR:
case TRUNC_DIV_EXPR:
if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
break;
return;
/* This isn't exactly what's specified above for operator<=>, but it's
close enough. In particular, we don't care about the return type
specified above; it doesn't participate in overload resolution and it
doesn't affect the semantics of the built-in operator. */
case SPACESHIP_EXPR:
case EQ_EXPR:
case NE_EXPR:
if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
|| (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2)))
break;
if (NULLPTR_TYPE_P (type1) && NULLPTR_TYPE_P (type2))
break;
if (TYPE_PTRMEM_P (type1) && null_ptr_cst_p (args[1]))
{
type2 = type1;
break;
}
if (TYPE_PTRMEM_P (type2) && null_ptr_cst_p (args[0]))
{
type1 = type2;
break;
}
/* Fall through. */
case LT_EXPR:
case GT_EXPR:
case LE_EXPR:
case GE_EXPR:
case MAX_EXPR:
case MIN_EXPR:
if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
break;
if (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
break;
if (TREE_CODE (type1) == ENUMERAL_TYPE
&& TREE_CODE (type2) == ENUMERAL_TYPE)
break;
if (TYPE_PTR_P (type1)
&& null_ptr_cst_p (args[1]))
{
type2 = type1;
break;
}
if (null_ptr_cst_p (args[0])
&& TYPE_PTR_P (type2))
{
type1 = type2;
break;
}
return;
case PLUS_EXPR:
if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
break;
/* FALLTHRU */
case ARRAY_REF:
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && TYPE_PTROB_P (type2))
{
type1 = ptrdiff_type_node;
break;
}
if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
{
type2 = ptrdiff_type_node;
break;
}
return;
/* 18For every pair of promoted integral types L and R, there exist candi-
date operator functions of the form
LR operator%(L, R);
LR operator&(L, R);
LR operator^(L, R);
LR operator|(L, R);
L operator<<(L, R);
L operator>>(L, R);
where LR is the result of the usual arithmetic conversions between
types L and R. */
case TRUNC_MOD_EXPR:
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case LSHIFT_EXPR:
case RSHIFT_EXPR:
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
break;
return;
/* 19For every triple L, VQ, R), where L is an arithmetic or enumeration
type, VQ is either volatile or empty, and R is a promoted arithmetic
type, there exist candidate operator functions of the form
VQ L& operator=(VQ L&, R);
VQ L& operator*=(VQ L&, R);
VQ L& operator/=(VQ L&, R);
VQ L& operator+=(VQ L&, R);
VQ L& operator-=(VQ L&, R);
20For every pair T, VQ), where T is any type and VQ is either volatile
or empty, there exist candidate operator functions of the form
T*VQ& operator=(T*VQ&, T*);
21For every pair T, VQ), where T is a pointer to member type and VQ is
either volatile or empty, there exist candidate operator functions of
the form
VQ T& operator=(VQ T&, T);
22For every triple T, VQ, I), where T is a cv-qualified or cv-
unqualified complete object type, VQ is either volatile or empty, and
I is a promoted integral type, there exist candidate operator func-
tions of the form
T*VQ& operator+=(T*VQ&, I);
T*VQ& operator-=(T*VQ&, I);
23For every triple L, VQ, R), where L is an integral or enumeration
type, VQ is either volatile or empty, and R is a promoted integral
type, there exist candidate operator functions of the form
VQ L& operator%=(VQ L&, R);
VQ L& operator<<=(VQ L&, R);
VQ L& operator>>=(VQ L&, R);
VQ L& operator&=(VQ L&, R);
VQ L& operator^=(VQ L&, R);
VQ L& operator|=(VQ L&, R); */
case MODIFY_EXPR:
switch (code2)
{
case PLUS_EXPR:
case MINUS_EXPR:
if (TYPE_PTROB_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
{
type2 = ptrdiff_type_node;
break;
}
/* FALLTHRU */
case MULT_EXPR:
case TRUNC_DIV_EXPR:
if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
break;
return;
case TRUNC_MOD_EXPR:
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case LSHIFT_EXPR:
case RSHIFT_EXPR:
if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type1) && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type2))
break;
return;
case NOP_EXPR:
if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2))
break;
if ((TYPE_PTRMEMFUNC_P (type1) && TYPE_PTRMEMFUNC_P (type2))
|| (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
|| (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2))
|| ((TYPE_PTRMEMFUNC_P (type1)
|| TYPE_PTR_P (type1))
&& null_ptr_cst_p (args[1])))
{
type2 = type1;
break;
}
return;
default:
gcc_unreachable ();
}
type1 = build_reference_type (type1);
break;
case COND_EXPR:
/* [over.built]
For every pair of promoted arithmetic types L and R, there
exist candidate operator functions of the form
LR operator?(bool, L, R);
where LR is the result of the usual arithmetic conversions
between types L and R.
For every type T, where T is a pointer or pointer-to-member
type, there exist candidate operator functions of the form T
operator?(bool, T, T); */
if (promoted_arithmetic_type_p (type1)
&& promoted_arithmetic_type_p (type2))
/* That's OK. */
break;
/* Otherwise, the types should be pointers. */
if (!TYPE_PTR_OR_PTRMEM_P (type1) || !TYPE_PTR_OR_PTRMEM_P (type2))
return;
/* We don't check that the two types are the same; the logic
below will actually create two candidates; one in which both
parameter types are TYPE1, and one in which both parameter
types are TYPE2. */
break;
case REALPART_EXPR:
case IMAGPART_EXPR:
if (ARITHMETIC_TYPE_P (type1))
break;
return;
default:
gcc_unreachable ();
}
/* Make sure we don't create builtin candidates with dependent types. */
bool u1 = uses_template_parms (type1);
bool u2 = type2 ? uses_template_parms (type2) : false;
if (u1 || u2)
{
/* Try to recover if one of the types is non-dependent. But if
there's only one type, there's nothing we can do. */
if (!type2)
return;
/* And we lose if both are dependent. */
if (u1 && u2)
return;
/* Or if they have different forms. */
if (TREE_CODE (type1) != TREE_CODE (type2))
return;
if (u1 && !u2)
type1 = type2;
else if (u2 && !u1)
type2 = type1;
}
/* If we're dealing with two pointer types or two enumeral types,
we need candidates for both of them. */
if (type2 && !same_type_p (type1, type2)
&& TREE_CODE (type1) == TREE_CODE (type2)
&& (TYPE_REF_P (type1)
|| (TYPE_PTR_P (type1) && TYPE_PTR_P (type2))
|| (TYPE_PTRDATAMEM_P (type1) && TYPE_PTRDATAMEM_P (type2))
|| TYPE_PTRMEMFUNC_P (type1)
|| MAYBE_CLASS_TYPE_P (type1)
|| TREE_CODE (type1) == ENUMERAL_TYPE))
{
if (TYPE_PTR_OR_PTRMEM_P (type1))
{
tree cptype = composite_pointer_type (input_location,
type1, type2,
error_mark_node,
error_mark_node,
CPO_CONVERSION,
tf_none);
if (cptype != error_mark_node)
{
build_builtin_candidate
(candidates, fnname, cptype, cptype, args, argtypes,
flags, complain);
return;
}
}
build_builtin_candidate
(candidates, fnname, type1, type1, args, argtypes, flags, complain);
build_builtin_candidate
(candidates, fnname, type2, type2, args, argtypes, flags, complain);
return;
}
build_builtin_candidate
(candidates, fnname, type1, type2, args, argtypes, flags, complain);
}
tree
type_decays_to (tree type)
{
if (TREE_CODE (type) == ARRAY_TYPE)
return build_pointer_type (TREE_TYPE (type));
if (TREE_CODE (type) == FUNCTION_TYPE)
return build_pointer_type (type);
return type;
}
/* There are three conditions of builtin candidates:
1) bool-taking candidates. These are the same regardless of the input.
2) pointer-pair taking candidates. These are generated for each type
one of the input types converts to.
3) arithmetic candidates. According to the standard, we should generate
all of these, but I'm trying not to...
Here we generate a superset of the possible candidates for this particular
case. That is a subset of the full set the standard defines, plus some
other cases which the standard disallows. add_builtin_candidate will
filter out the invalid set. */
static void
add_builtin_candidates (struct z_candidate **candidates, enum tree_code code,
enum tree_code code2, tree fnname,
vec<tree, va_gc> *argv,
int flags, tsubst_flags_t complain)
{
int ref1;
int enum_p = 0;
tree type, argtypes[3], t;
/* TYPES[i] is the set of possible builtin-operator parameter types
we will consider for the Ith argument. */
vec<tree, va_gc> *types[2];
unsigned ix;
vec<tree, va_gc> &args = *argv;
unsigned