diff options
Diffstat (limited to 'gcc-4.9/gcc/cp/call.c')
| -rw-r--r-- | gcc-4.9/gcc/cp/call.c | 9544 |
1 files changed, 9544 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/cp/call.c b/gcc-4.9/gcc/cp/call.c new file mode 100644 index 000000000..877f6d9cf --- /dev/null +++ b/gcc-4.9/gcc/cp/call.c @@ -0,0 +1,9544 @@ +/* Functions related to invoking methods and overloaded functions. + Copyright (C) 1987-2014 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 "tm.h" +#include "tree.h" +#include "stor-layout.h" +#include "trans-mem.h" +#include "stringpool.h" +#include "cp-tree.h" +#include "flags.h" +#include "toplev.h" +#include "diagnostic-core.h" +#include "intl.h" +#include "target.h" +#include "convert.h" +#include "langhooks.h" +#include "c-family/c-objc.h" +#include "timevar.h" +#include "cgraph.h" + +/* The various kinds of conversion. */ + +typedef enum conversion_kind { + ck_identity, + ck_lvalue, + ck_qual, + ck_std, + ck_ptr, + ck_pmem, + ck_base, + ck_ref_bind, + ck_user, + ck_ambig, + ck_list, + ck_aggr, + ck_rvalue +} conversion_kind; + +/* The rank of the conversion. Order of the enumerals matters; better + conversions should come earlier in the list. */ + +typedef enum conversion_rank { + cr_identity, + cr_exact, + cr_promotion, + cr_std, + cr_pbool, + cr_user, + cr_ellipsis, + cr_bad +} conversion_rank; + +/* 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. */ + +typedef struct conversion 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 ck_base_conv, true to indicate that a + temporary should be created to hold the result of the + conversion. */ + 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, + true when we should treat an lvalue as an rvalue (12.8p33). If + KIND is ck_base, always false. */ + BOOL_BITFIELD rvaluedness_matches_p: 1; + BOOL_BITFIELD check_narrowing: 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_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 or ck_ambig. */ + 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 tree build_over_call (struct z_candidate *, int, tsubst_flags_t); +static tree build_java_interface_fn_ref (tree, tree); +#define convert_like(CONV, EXPR, COMPLAIN) \ + convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \ + /*issue_conversion_warnings=*/true, \ + /*c_cast_p=*/false, (COMPLAIN)) +#define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \ + convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \ + /*issue_conversion_warnings=*/true, \ + /*c_cast_p=*/false, (COMPLAIN)) +static tree convert_like_real (conversion *, tree, tree, int, int, bool, + bool, tsubst_flags_t); +static void op_error (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, 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, tsubst_flags_t); +static struct z_candidate *add_template_conv_candidate + (struct z_candidate **, tree, tree, tree, const vec<tree, va_gc> *, + tree, tree, tree, tsubst_flags_t); +static void add_builtin_candidates + (struct z_candidate **, enum tree_code, enum tree_code, + tree, tree *, int, tsubst_flags_t); +static void add_builtin_candidate + (struct z_candidate **, enum tree_code, enum tree_code, + tree, tree, tree, tree *, tree *, int, tsubst_flags_t); +static bool is_complete (tree); +static void build_builtin_candidate + (struct z_candidate **, tree, tree, tree, tree *, tree *, + int, tsubst_flags_t); +static struct z_candidate *add_conv_candidate + (struct z_candidate **, tree, 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, tsubst_flags_t); +static conversion *implicit_conversion (tree, tree, tree, bool, int, + tsubst_flags_t); +static conversion *standard_conversion (tree, tree, tree, bool, int); +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 *); +static tree source_type (conversion *); +static void add_warning (struct z_candidate *, struct z_candidate *); +static bool reference_compatible_p (tree, tree); +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); + +/* 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) + && name == constructor_name (basetype)) + || (TREE_CODE (basetype) == ENUMERAL_TYPE + && name == TYPE_IDENTIFIER (basetype))) + return true; + else + name = get_type_value (name); + } + 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; + } + + if (!name || name == error_mark_node) + 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 + function = decay_conversion (function, complain); + + 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) +{ + int nothrow; + tree decl = get_callee_fndecl (call); + + /* We check both the decl and the type; a function may be known not to + throw without being declared throw(). */ + nothrow = ((decl && TREE_NOTHROW (decl)) + || TYPE_NOTHROW_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (call))))); + + if (!nothrow && at_function_scope_p () && cfun && cp_function_chain) + cp_function_chain->can_throw = 1; + + if (decl && TREE_THIS_VOLATILE (decl) && cfun && cp_function_chain) + 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 (TREE_CODE (fntype) == FUNCTION_TYPE + || TREE_CODE (fntype) == METHOD_TYPE); + 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); + } + + if (decl && TREE_DEPRECATED (decl)) + warn_deprecated_use (decl, NULL_TREE); + 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 || ! DECL_BUILT_IN (decl)) + for (i = 0; i < n; i++) + { + tree arg = CALL_EXPR_ARG (function, i); + if (is_empty_class (TREE_TYPE (arg)) + && ! TREE_ADDRESSABLE (TREE_TYPE (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; +} + +/* Build something of the form ptr->method (args) + or object.method (args). This can also build + calls to constructors, and find friends. + + Member functions always take their class variable + as a pointer. + + INSTANCE is a class instance. + + NAME is the name of the method desired, usually an IDENTIFIER_NODE. + + PARMS help to figure out what that NAME really refers to. + + BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE + down to the real instance type to use for access checking. We need this + information to get protected accesses correct. + + FLAGS is the logical disjunction of zero or more LOOKUP_ + flags. See cp-tree.h for more info. + + If this is all OK, calls build_function_call with the resolved + member function. + + This function must also handle being called to perform + initialization, promotion/coercion of arguments, and + instantiation of default parameters. + + Note that NAME may refer to an instance variable name. If + `operator()()' is defined for the type of that field, then we return + that result. */ + +/* New overloading code. */ + +typedef struct z_candidate z_candidate; + +typedef struct candidate_warning candidate_warning; +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 +}; + +struct conversion_info { + /* The index of the argument, 0-based. */ + int n_arg; + /* The type of the actual argument. */ + tree from_type; + /* The type of the formal argument. */ + tree to_type; +}; + +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 the call was a varargs call. */ + bool call_varargs_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; + int viable; + 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; +}; + +/* Returns true iff T is a null pointer constant in the sense of + [conv.ptr]. */ + +bool +null_ptr_cst_p (tree t) +{ + /* [conv.ptr] + + A null pointer constant is an integral constant expression + (_expr.const_) rvalue of integer type that evaluates to zero or + an rvalue of type std::nullptr_t. */ + if (NULLPTR_TYPE_P (TREE_TYPE (t))) + return true; + if (CP_INTEGRAL_TYPE_P (TREE_TYPE (t))) + { + /* Core issue 903 says only literal 0 is a null pointer constant. */ + if (cxx_dialect < cxx11) + t = maybe_constant_value (fold_non_dependent_expr_sfinae (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 + && 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) +{ + 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; + return r; +} + +static struct rejection_reason * +arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to) +{ + 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_type = from; + r->u.conversion.to_type = to; + return r; +} + +static struct rejection_reason * +bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to) +{ + 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_type = from; + r->u.bad_conversion.to_type = to; + 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_type = from; + r->u.conversion.to_type = to; + 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_type = from; + r->u.conversion.to_type = to; + 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; +} + +/* 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; +} + +#ifdef ENABLE_CHECKING + +/* 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))); +} + +#endif /* ENABLE_CHECKING */ + +/* Dynamically allocate an array of N conversions. */ + +static conversion ** +alloc_conversions (size_t n) +{ + return (conversion **) conversion_obstack_alloc (n * sizeof (conversion *)); +} + +static conversion * +build_conv (conversion_kind code, tree type, conversion *from) +{ + conversion *t; + conversion_rank rank = CONVERSION_RANK (from); + + /* 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: + 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; + + 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 + || conv->kind == ck_identity + || conv->kind == ck_ambig + || conv->kind == ck_list) + return NULL; + return conv->u.next; +} + +/* Subroutine of build_aggr_conv: check whether CTOR, a braced-init-list, + is a valid aggregate initializer for array type ATYPE. */ + +static bool +can_convert_array (tree atype, tree ctor, int flags, tsubst_flags_t complain) +{ + unsigned i; + tree elttype = TREE_TYPE (atype); + for (i = 0; i < CONSTRUCTOR_NELTS (ctor); ++i) + { + tree val = CONSTRUCTOR_ELT (ctor, i)->value; + bool ok; + if (TREE_CODE (elttype) == ARRAY_TYPE + && TREE_CODE (val) == CONSTRUCTOR) + 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; +} + +/* 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; + + ctor = reshape_init (type, ctor, tf_none); + if (ctor == error_mark_node) + return NULL; + + flags |= LOOKUP_NO_NARROWING; + + for (; field; field = next_initializable_field (DECL_CHAIN (field))) + { + tree ftype = TREE_TYPE (field); + tree val; + bool ok; + + if (i < CONSTRUCTOR_NELTS (ctor)) + val = CONSTRUCTOR_ELT (ctor, i)->value; + else if (TREE_CODE (ftype) == REFERENCE_TYPE) + /* 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; + } + ++i; + + if (TREE_CODE (ftype) == ARRAY_TYPE + && TREE_CODE (val) == CONSTRUCTOR) + 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.next = NULL; + 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; + + 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; + } + + 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.next = NULL; + 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; + + 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.next = NULL; + 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) +{ + enum tree_code fcode, tcode; + conversion *conv; + bool fromref = false; + tree qualified_to; + + to = non_reference (to); + if (TREE_CODE (from) == REFERENCE_TYPE) + { + fromref = true; + from = TREE_TYPE (from); + } + qualified_to = to; + to = strip_top_quals (to); + from = strip_top_quals (from); + + if ((TYPE_PTRFN_P (to) || TYPE_PTRMEMFUNC_P (to)) + && expr && type_unknown_p (expr)) + { + tsubst_flags_t tflags = tf_conv; + expr = instantiate_type (to, expr, tflags); + if (expr == error_mark_node) + return NULL; + 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); + conv = build_conv (ck_lvalue, from, conv); + } + else if (fromref || (expr && lvalue_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) + conv->rvaluedness_matches_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); + + if (part_conv) + { + conv = build_conv (part_conv->kind, to, conv); + conv->rank = part_conv->rank; + } + else + conv = NULL; + + 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)) + 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 + && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (from), + TREE_TYPE (to))) + ; + else if (VOID_TYPE_P (TREE_TYPE (to)) + && !TYPE_PTRDATAMEM_P (from) + && TREE_CODE (TREE_TYPE (from)) != FUNCTION_TYPE) + { + tree nfrom = TREE_TYPE (from); + from = build_pointer_type + (cp_build_qualified_type (void_type_node, + cp_type_quals (nfrom))); + 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 (DERIVED_FROM_P (fbase, tbase) + && (same_type_ignoring_top_level_qualifiers_p + (TYPE_PTRMEM_POINTED_TO_TYPE (from), + TYPE_PTRMEM_POINTED_TO_TYPE (to)))) + { + from = build_ptrmem_type (tbase, + TYPE_PTRMEM_POINTED_TO_TYPE (from)); + conv = build_conv (ck_pmem, from, conv); + } + else if (!same_type_p (fbase, tbase)) + return NULL; + } + else if (CLASS_TYPE_P (TREE_TYPE (from)) + && CLASS_TYPE_P (TREE_TYPE (to)) + /* [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 (TREE_TYPE (to), TREE_TYPE (from))) + { + from = + cp_build_qualified_type (TREE_TYPE (to), + cp_type_quals (TREE_TYPE (from))); + from = build_pointer_type (from); + conv = build_conv (ck_ptr, from, conv); + conv->base_p = true; + } + + if (tcode == POINTER_TYPE) + { + to_pointee = TREE_TYPE (to); + from_pointee = TREE_TYPE (from); + } + else + { + to_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (to); + from_pointee = TYPE_PTRMEM_POINTED_TO_TYPE (from); + } + + if (same_type_p (from, to)) + /* OK */; + else if (c_cast_p && comp_ptr_ttypes_const (to, from)) + /* 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); + /* 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 (!DERIVED_FROM_P (fbase, tbase) + || !same_type_p (static_fn_type (fromfn), + static_fn_type (tofn))) + return NULL; + + from = build_memfn_type (fromfn, + 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; + } + else if (tcode == BOOLEAN_TYPE) + { + /* [conv.bool] + + An rvalue of arithmetic, unscoped enumeration, pointer, or + pointer to member type can be converted to an rvalue of type + bool. ... An rvalue of type std::nullptr_t can be converted + to an rvalue 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; + 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; + conv = build_conv (ck_std, to, conv); + + /* Give this a better rank if it's a promotion. */ + if (same_type_p (to, type_promotes_to (from)) + && 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); + } + 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 the same type as T2, or T1 is a base class + of T2. */ + return (same_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. */ + +static bool +reference_compatible_p (tree t1, tree t2) +{ + /* [dcl.init.ref] + + "cv1 T1" is reference compatible with "cv2 T2" if T1 is + reference-related to T2 and cv1 is the same cv-qualification as, + or greater cv-qualification than, cv2. */ + return (reference_related_p (t1, t2) + && at_least_as_qualified_p (t1, t2)); +} + +/* 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 (TREE_CODE (type) == REFERENCE_TYPE); + gcc_assert (TREE_CODE (conv->type) != REFERENCE_TYPE); + + t = TREE_TYPE (type); + + /* [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 (!same_type_ignoring_top_level_qualifiers_p (t, conv->type)) + { + /* 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; + } + 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); + } + + 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... */ + if (CONSTRUCTOR_NELTS (expr) == 1) + { + 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 or + direct-list-initialized, depending on the kind of initialization + for the reference, and the reference is bound to that temporary. */ + conv = implicit_conversion (to, from, expr, c_cast_p, + flags|LOOKUP_NO_TEMP_BIND, complain); + skip:; + } + + if (TREE_CODE (from) == REFERENCE_TYPE) + { + 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); + if (gl_kind & clk_class) + /* A class prvalue is not a glvalue. */ + gl_kind = clk_none; + } + else + gl_kind = clk_none; + is_lvalue = gl_kind && !(gl_kind & clk_rvalueref); + + 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 do 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 (compatible_p + && (is_lvalue + || (((CP_TYPE_CONST_NON_VOLATILE_P (to) + && !(flags & LOOKUP_NO_RVAL_BIND)) + || TYPE_REF_IS_RVALUE (rto)) + && (gl_kind + || (!(flags & LOOKUP_NO_TEMP_BIND) + && (CLASS_TYPE_P (from) + || TREE_CODE (from) == ARRAY_TYPE)))))) + { + /* [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 (flags & LOOKUP_PREFER_RVALUE) + /* The top-level caller requested that we pretend that the lvalue + be treated as an rvalue. */ + conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto); + else if (TREE_CODE (rfrom) == REFERENCE_TYPE) + /* 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 + && !(flags & LOOKUP_PREFER_RVALUE)) + 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. */ + if (!CP_TYPE_CONST_NON_VOLATILE_P (to) && !TYPE_REF_IS_RVALUE (rto)) + return NULL; + + /* [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)) + 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; + + 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; + if (TYPE_REF_IS_RVALUE (rto)) + { + conv->rvaluedness_matches_p = 1; + /* In the second case, if the reference is an rvalue reference and + the second standard conversion sequence of the user-defined + conversion sequence includes an lvalue-to-rvalue conversion, the + program is ill-formed. */ + if (conv->user_conv_p && next_conversion (conv)->kind == ck_rvalue) + conv->bad_p = 1; + } + + return conv; +} + +/* 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; + + 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; + + if (TREE_CODE (to) == REFERENCE_TYPE) + conv = reference_binding (to, from, expr, c_cast_p, flags, complain); + else + conv = standard_conversion (to, from, expr, c_cast_p, flags); + + if (conv) + return conv; + + if (expr && BRACE_ENCLOSED_INITIALIZER_P (expr)) + { + if (is_std_init_list (to)) + return build_list_conv (to, expr, flags, complain); + + /* As an extension, allow list-initialization of _Complex. */ + if (TREE_CODE (to) == COMPLEX_TYPE) + { + 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) + 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) + 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; +} + +/* 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) +{ + 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; + *candidates = cand; + + return cand; +} + +/* Return the number of remaining arguments in the parameter list + beginning with ARG. */ + +static int +remaining_arguments (tree arg) +{ + int n; + + for (n = 0; arg != NULL_TREE && arg != void_list_node; + arg = TREE_CHAIN (arg)) + n++; + + return n; +} + +/* 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. */ + +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, + tsubst_flags_t complain) +{ + tree parmlist = TYPE_ARG_TYPES (TREE_TYPE (fn)); + int i, len; + conversion **convs; + tree parmnode; + tree orig_first_arg = first_arg; + int skip; + int viable = 1; + struct rejection_reason *reason = NULL; + + /* At this point we should not see any functions which haven't been + explicitly declared, except for friend functions which will have + been found using argument dependent lookup. */ + gcc_assert (!DECL_ANTICIPATED (fn) || DECL_HIDDEN_FRIEND_P (fn)); + + /* The `this', `in_chrg' and VTT arguments to constructors are not + considered in overload resolution. */ + if (DECL_CONSTRUCTOR_P (fn)) + { + 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); + 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); + } + /* 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. */ + else if (parmlist && (flags & LOOKUP_DEFAULTED)) + { + if (DECL_CONSTRUCTOR_P (fn)) + i = 1; + else if (DECL_ASSIGNMENT_OPERATOR_P (fn) + && DECL_OVERLOADED_OPERATOR_P (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; + + /* Second, 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; + conversion *t; + int is_this; + + if (parmnode == void_list_node) + break; + + 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); + + is_this = (i == 0 && DECL_NONSTATIC_MEMBER_FUNCTION_P (fn) + && ! DECL_CONSTRUCTOR_P (fn)); + + if (parmnode) + { + tree parmtype = TREE_VALUE (parmnode); + int lflags = flags; + + parmnode = TREE_CHAIN (parmnode); + + /* 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. */ + if (ctype && is_this) + { + parmtype = cp_build_qualified_type + (ctype, cp_type_quals (TREE_TYPE (parmtype))); + 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); + } + else + { + parmtype = build_pointer_type (parmtype); + arg = build_this (arg); + argtype = lvalue_type (arg); + } + } + + /* 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 set LOOKUP_COPY_PARM to let reference_binding know that + it's being called in that context. We generalize the above + to handle move constructors and template constructors as well; + the standardese should soon be updated similarly. */ + if (ctype && i == 0 && (len-skip == 1) + && DECL_CONSTRUCTOR_P (fn) + && parmtype != error_mark_node + && (same_type_ignoring_top_level_qualifiers_p + (non_reference (parmtype), ctype))) + { + if (!(flags & LOOKUP_ONLYCONVERTING)) + lflags |= LOOKUP_COPY_PARM; + /* We allow user-defined conversions within init-lists, but + don't list-initialize the copy parm, as that would mean + using two levels of braces for the same type. */ + if ((flags & LOOKUP_LIST_INIT_CTOR) + && BRACE_ENCLOSED_INITIALIZER_P (arg)) + lflags |= LOOKUP_NO_CONVERSION; + } + else + lflags |= LOOKUP_ONLYCONVERTING; + + t = implicit_conversion (parmtype, argtype, arg, + /*c_cast_p=*/false, lflags, complain); + to_type = parmtype; + } + else + { + t = build_identity_conv (argtype, arg); + t->ellipsis_p = true; + to_type = argtype; + } + + if (t && is_this) + t->this_p = true; + + convs[i] = t; + if (! t) + { + viable = 0; + reason = arg_conversion_rejection (first_arg, i, argtype, to_type); + break; + } + + if (t->bad_p) + { + viable = -1; + reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type); + } + } + + out: + return add_candidate (candidates, fn, orig_first_arg, args, len, convs, + access_path, conversion_path, viable, reason); +} + +/* 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, + tree first_arg, 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) + (first_arg != NULL_TREE ? 1 : 0) + 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 if (i == 1 && first_arg != NULL_TREE) + arg = first_arg; + else + arg = (*arglist)[i - (first_arg != NULL_TREE ? 1 : 0) - 1]; + argtype = lvalue_type (arg); + + if (i == 0) + { + t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false, + flags, complain); + 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, argtype, convert_type); + } + + 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, first_arg, arglist, len, convs, + access_path, conversion_path, viable, reason); +} + +static void +build_builtin_candidate (struct z_candidate **candidates, tree fnname, + tree type1, tree type2, tree *args, tree *argtypes, + int flags, tsubst_flags_t complain) +{ + conversion *t; + conversion **convs; + size_t num_convs; + int viable = 1, i; + tree types[2]; + struct rejection_reason *reason = NULL; + + types[0] = type1; + types[1] = type2; + + num_convs = args[2] ? 3 : (args[1] ? 2 : 1); + 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 (i = 0; i < 2; ++i) + { + if (! args[i]) + break; + + 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]); + } + else if (t->bad_p) + { + viable = 0; + reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], + types[i]); + } + convs[i] = t; + } + + /* For COND_EXPR we rearranged the arguments; undo that now. */ + if (args[2]) + { + 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); + } + } + + add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL, + num_convs, convs, + /*access_path=*/NULL_TREE, + /*conversion_path=*/NULL_TREE, + viable, reason); +} + +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, tree *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 or enumeration type, + 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 enumeration type or 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 + complete 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; + case POSTINCREMENT_EXPR: + case PREINCREMENT_EXPR: + 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, 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*); + + 10For every promoted arithmetic 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; + case NEGATE_EXPR: + if (ARITHMETIC_TYPE_P (type1)) + break; + return; + +/* 11For 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; + +/* 12For 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, T is a complete + object type or a function type, and CV1 and CV2 are cv-qualifier-seqs, + 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; + +/* 13For every pair of promoted arithmetic types L and R, there exist can- + didate 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. + + 14For every pair of types T and I, where T is a cv-qualified or cv- + unqualified complete object type and I is a promoted integral type, + there exist candidate operator functions of the form + T* operator+(T*, I); + T& operator[](T*, I); + T* operator-(T*, I); + T* operator+(I, T*); + T& operator[](I, T*); + + 15For every T, where T is a pointer to complete object type, there exist + candidate operator functions of the form112) + ptrdiff_t operator-(T, T); + + 16For every pointer or enumeration type T, 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); + + 17For every pointer to member type 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; + } + case MULT_EXPR: + case TRUNC_DIV_EXPR: + if (ARITHMETIC_TYPE_P (type1) && ARITHMETIC_TYPE_P (type2)) + break; + return; + + 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 (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; + 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; + } + 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) + && (TREE_CODE (type1) == REFERENCE_TYPE + || (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 (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, tree *args, + int flags, tsubst_flags_t complain) +{ + int ref1, i; + 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; + + for (i = 0; i < 3; ++i) + { + if (args[i]) + argtypes[i] = unlowered_expr_type (args[i]); + else + argtypes[i] = NULL_TREE; + } + + switch (code) + { +/* 4 For every pair T, VQ), where T is an arithmetic or enumeration type, + and VQ is either volatile or empty, there exist candidate operator + functions of the form + VQ T& operator++(VQ T&); */ + + case POSTINCREMENT_EXPR: + case PREINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + case PREDECREMENT_EXPR: + case MODIFY_EXPR: + ref1 = 1; + break; + +/* 24There also exist candidate operator functions of the form + bool operator!(bool); + bool operator&&(bool, bool); + bool operator||(bool, bool); */ + + case TRUTH_NOT_EXPR: + build_builtin_candidate + (candidates, fnname, boolean_type_node, + NULL_TREE, args, argtypes, flags, complain); + return; + + case TRUTH_ORIF_EXPR: + case TRUTH_ANDIF_EXPR: + build_builtin_candidate + (candidates, fnname, boolean_type_node, + boolean_type_node, args, argtypes, flags, complain); + return; + + case ADDR_EXPR: + case COMPOUND_EXPR: + case COMPONENT_REF: + return; + + case COND_EXPR: + case EQ_EXPR: + case NE_EXPR: + case LT_EXPR: + case LE_EXPR: + case GT_EXPR: + case GE_EXPR: + enum_p = 1; + /* Fall through. */ + + default: + ref1 = 0; + } + + types[0] = make_tree_vector (); + types[1] = make_tree_vector (); + + for (i = 0; i < 2; ++i) + { + if (! args[i]) + ; + else if (MAYBE_CLASS_TYPE_P (argtypes[i])) + { + tree convs; + + if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR) + return; + + convs = lookup_conversions (argtypes[i]); + + if (code == COND_EXPR) + { + if (real_lvalue_p (args[i])) + vec_safe_push (types[i], build_reference_type (argtypes[i])); + + vec_safe_push (types[i], TYPE_MAIN_VARIANT (argtypes[i])); + } + + else if (! convs) + return; + + for (; convs; convs = TREE_CHAIN (convs)) + { + type = TREE_TYPE (convs); + + if (i == 0 && ref1 + && (TREE_CODE (type) != REFERENCE_TYPE + || CP_TYPE_CONST_P (TREE_TYPE (type)))) + continue; + + if (code == COND_EXPR && TREE_CODE (type) == REFERENCE_TYPE) + vec_safe_push (types[i], type); + + type = non_reference (type); + if (i != 0 || ! ref1) + { + type = cv_unqualified (type_decays_to (type)); + if (enum_p && TREE_CODE (type) == ENUMERAL_TYPE) + vec_safe_push (types[i], type); + if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type)) + type = type_promotes_to (type); + } + + if (! vec_member (type, types[i])) + vec_safe_push (types[i], type); + } + } + else + { + if (code == COND_EXPR && real_lvalue_p (args[i])) + vec_safe_push (types[i], build_reference_type (argtypes[i])); + type = non_reference (argtypes[i]); + if (i != 0 || ! ref1) + { + type = cv_unqualified (type_decays_to (type)); + if (enum_p && UNSCOPED_ENUM_P (type)) + vec_safe_push (types[i], type); + if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type)) + type = type_promotes_to (type); + } + vec_safe_push (types[i], type); + } + } + + /* Run through the possible parameter types of both arguments, + creating candidates with those parameter types. */ + FOR_EACH_VEC_ELT_REVERSE (*(types[0]), ix, t) + { + unsigned jx; + tree u; + + if (!types[1]->is_empty ()) + FOR_EACH_VEC_ELT_REVERSE (*(types[1]), jx, u) + add_builtin_candidate + (candidates, code, code2, fnname, t, + u, args, argtypes, flags, complain); + else + add_builtin_candidate + (candidates, code, code2, fnname, t, + NULL_TREE, args, argtypes, flags, complain); + } + + release_tree_vector (types[0]); + release_tree_vector (types[1]); +} + + +/* If TMPL can be successfully instantiated as indicated by + EXPLICIT_TARGS and ARGLIST, adds the instantiation to CANDIDATES. + + TMPL is the template. EXPLICIT_TARGS are any explicit template + arguments. ARGLIST is the arguments provided at the call-site. + This does not change ARGLIST. The RETURN_TYPE is the desired type + for conversion operators. If OBJ is NULL_TREE, FLAGS and CTYPE are + as for add_function_candidate. If an OBJ is supplied, FLAGS and + CTYPE are ignored, and OBJ is as for add_conv_candidate. */ + +static struct z_candidate* +add_template_candidate_real (struct z_candidate **candidates, tree tmpl, + tree ctype, tree explicit_targs, tree first_arg, + const vec<tree, va_gc> *arglist, tree return_type, + tree access_path, tree conversion_path, + int flags, tree obj, unification_kind_t strict, + tsubst_flags_t complain) +{ + int ntparms = DECL_NTPARMS (tmpl); + tree targs = make_tree_vec (ntparms); + unsigned int len = vec_safe_length (arglist); + unsigned int nargs = (first_arg == NULL_TREE ? 0 : 1) + len; + unsigned int skip_without_in_chrg = 0; + tree first_arg_without_in_chrg = first_arg; + tree *args_without_in_chrg; + unsigned int nargs_without_in_chrg; + unsigned int ia, ix; + tree arg; + struct z_candidate *cand; + tree fn; + struct rejection_reason *reason = NULL; + int errs; + + /* We don't do deduction on the in-charge parameter, the VTT + parameter or 'this'. */ + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (tmpl)) + { + if (first_arg_without_in_chrg != NULL_TREE) + first_arg_without_in_chrg = NULL_TREE; + else + ++skip_without_in_chrg; + } + + if ((DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (tmpl) + || DECL_BASE_CONSTRUCTOR_P (tmpl)) + && CLASSTYPE_VBASECLASSES (DECL_CONTEXT (tmpl))) + { + if (first_arg_without_in_chrg != NULL_TREE) + first_arg_without_in_chrg = NULL_TREE; + else + ++skip_without_in_chrg; + } + + if (len < skip_without_in_chrg) + return NULL; + + nargs_without_in_chrg = ((first_arg_without_in_chrg != NULL_TREE ? 1 : 0) + + (len - skip_without_in_chrg)); + args_without_in_chrg = XALLOCAVEC (tree, nargs_without_in_chrg); + ia = 0; + if (first_arg_without_in_chrg != NULL_TREE) + { + args_without_in_chrg[ia] = first_arg_without_in_chrg; + ++ia; + } + for (ix = skip_without_in_chrg; + vec_safe_iterate (arglist, ix, &arg); + ++ix) + { + args_without_in_chrg[ia] = arg; + ++ia; + } + gcc_assert (ia == nargs_without_in_chrg); + + errs = errorcount+sorrycount; + fn = fn_type_unification (tmpl, explicit_targs, targs, + args_without_in_chrg, + nargs_without_in_chrg, + return_type, strict, flags, false, + complain & tf_decltype); + + if (fn == error_mark_node) + { + /* Don't repeat unification later if it already resulted in errors. */ + if (errorcount+sorrycount == errs) + reason = template_unification_rejection (tmpl, explicit_targs, + targs, args_without_in_chrg, + nargs_without_in_chrg, + return_type, strict, flags); + else + reason = template_unification_error_rejection (); + goto fail; + } + + /* In [class.copy]: + + A member function template is never instantiated to perform the + copy of a class object to an object of its class type. + + It's a little unclear what this means; the standard explicitly + does allow a template to be used to copy a class. For example, + in: + + struct A { + A(A&); + template <class T> A(const T&); + }; + const A f (); + void g () { A a (f ()); } + + the member template will be used to make the copy. The section + quoted above appears in the paragraph that forbids constructors + whose only parameter is (a possibly cv-qualified variant of) the + class type, and a logical interpretation is that the intent was + to forbid the instantiation of member templates which would then + have that form. */ + if (DECL_CONSTRUCTOR_P (fn) && nargs == 2) + { + tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn); + if (arg_types && same_type_p (TYPE_MAIN_VARIANT (TREE_VALUE (arg_types)), + ctype)) + { + reason = invalid_copy_with_fn_template_rejection (); + goto fail; + } + } + + if (obj != NULL_TREE) + /* Aha, this is a conversion function. */ + cand = add_conv_candidate (candidates, fn, obj, first_arg, arglist, + access_path, conversion_path, complain); + else + cand = add_function_candidate (candidates, fn, ctype, + first_arg, arglist, access_path, + conversion_path, flags, complain); + if (DECL_TI_TEMPLATE (fn) != tmpl) + /* This situation can occur if a member template of a template + class is specialized. Then, instantiate_template might return + an instantiation of the specialization, in which case the + DECL_TI_TEMPLATE field will point at the original + specialization. For example: + + template <class T> struct S { template <class U> void f(U); + template <> void f(int) {}; }; + S<double> sd; + sd.f(3); + + Here, TMPL will be template <class U> S<double>::f(U). + And, instantiate template will give us the specialization + template <> S<double>::f(int). But, the DECL_TI_TEMPLATE field + for this will point at template <class T> template <> S<T>::f(int), + so that we can find the definition. For the purposes of + overload resolution, however, we want the original TMPL. */ + cand->template_decl = build_template_info (tmpl, targs); + else + cand->template_decl = DECL_TEMPLATE_INFO (fn); + cand->explicit_targs = explicit_targs; + + return cand; + fail: + return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL, + access_path, conversion_path, 0, reason); +} + + +static struct z_candidate * +add_template_candidate (struct z_candidate **candidates, tree tmpl, tree ctype, + tree explicit_targs, tree first_arg, + const vec<tree, va_gc> *arglist, tree return_type, + tree access_path, tree conversion_path, int flags, + unification_kind_t strict, tsubst_flags_t complain) +{ + return + add_template_candidate_real (candidates, tmpl, ctype, + explicit_targs, first_arg, arglist, + return_type, access_path, conversion_path, + flags, NULL_TREE, strict, complain); +} + + +static struct z_candidate * +add_template_conv_candidate (struct z_candidate **candidates, tree tmpl, + tree obj, tree first_arg, + const vec<tree, va_gc> *arglist, + tree return_type, tree access_path, + tree conversion_path, tsubst_flags_t complain) +{ + return + add_template_candidate_real (candidates, tmpl, NULL_TREE, NULL_TREE, + first_arg, arglist, return_type, access_path, + conversion_path, 0, obj, DEDUCE_CONV, + complain); +} + +/* The CANDS are the set of candidates that were considered for + overload resolution. Return the set of viable candidates, or CANDS + if none are viable. If any of the candidates were viable, set + *ANY_VIABLE_P to true. STRICT_P is true if a candidate should be + considered viable only if it is strictly viable. */ + +static struct z_candidate* +splice_viable (struct z_candidate *cands, + bool strict_p, + bool *any_viable_p) +{ + struct z_candidate *viable; + struct z_candidate **last_viable; + struct z_candidate **cand; + + /* Be strict inside templates, since build_over_call won't actually + do the conversions to get pedwarns. */ + if (processing_template_decl) + strict_p = true; + + viable = NULL; + last_viable = &viable; + *any_viable_p = false; + + cand = &cands; + while (*cand) + { + struct z_candidate *c = *cand; + if (strict_p ? c->viable == 1 : c->viable) + { + *last_viable = c; + *cand = c->next; + c->next = NULL; + last_viable = &c->next; + *any_viable_p = true; + } + else + cand = &c->next; + } + + return viable ? viable : cands; +} + +static bool +any_strictly_viable (struct z_candidate *cands) +{ + for (; cands; cands = cands->next) + if (cands->viable == 1) + return true; + return false; +} + +/* OBJ is being used in an expression like "OBJ.f (...)". In other + words, it is about to become the "this" pointer for a member + function call. Take the address of the object. */ + +static tree +build_this (tree obj) +{ + /* In a template, we are only concerned about the type of the + expression, so we can take a shortcut. */ + if (processing_template_decl) + return build_address (obj); + + return cp_build_addr_expr (obj, tf_warning_or_error); +} + +/* Returns true iff functions are equivalent. Equivalent functions are + not '==' only if one is a function-local extern function or if + both are extern "C". */ + +static inline int +equal_functions (tree fn1, tree fn2) +{ + if (TREE_CODE (fn1) != TREE_CODE (fn2)) + return 0; + if (TREE_CODE (fn1) == TEMPLATE_DECL) + return fn1 == fn2; + if (DECL_LOCAL_FUNCTION_P (fn1) || DECL_LOCAL_FUNCTION_P (fn2) + || DECL_EXTERN_C_FUNCTION_P (fn1)) + return decls_match (fn1, fn2); + return fn1 == fn2; +} + +/* Print information about a candidate being rejected due to INFO. */ + +static void +print_conversion_rejection (location_t loc, struct conversion_info *info) +{ + if (info->n_arg == -1) + /* Conversion of implicit `this' argument failed. */ + inform (loc, " no known conversion for implicit " + "%<this%> parameter from %qT to %qT", + info->from_type, info->to_type); + else if (info->n_arg == -2) + /* Conversion of conversion function return value failed. */ + inform (loc, " no known conversion from %qT to %qT", + info->from_type, info->to_type); + else + inform (loc, " no known conversion for argument %d from %qT to %qT", + info->n_arg+1, info->from_type, info->to_type); +} + +/* Print information about a candidate with WANT parameters and we found + HAVE. */ + +static void +print_arity_information (location_t loc, unsigned int have, unsigned int want) +{ + inform_n (loc, want, + " candidate expects %d argument, %d provided", + " candidate expects %d arguments, %d provided", + want, have); +} + +/* Print information about one overload candidate CANDIDATE. MSGSTR + is the text to print before the candidate itself. + + NOTE: Unlike most diagnostic functions in GCC, MSGSTR is expected + to have been run through gettext by the caller. This wart makes + life simpler in print_z_candidates and for the translators. */ + +static void +print_z_candidate (location_t loc, const char *msgstr, + struct z_candidate *candidate) +{ + const char *msg = (msgstr == NULL + ? "" + : ACONCAT ((msgstr, " ", NULL))); + location_t cloc = location_of (candidate->fn); + + if (identifier_p (candidate->fn)) + { + cloc = loc; + if (candidate->num_convs == 3) + inform (cloc, "%s%D(%T, %T, %T) <built-in>", msg, candidate->fn, + candidate->convs[0]->type, + candidate->convs[1]->type, + candidate->convs[2]->type); + else if (candidate->num_convs == 2) + inform (cloc, "%s%D(%T, %T) <built-in>", msg, candidate->fn, + candidate->convs[0]->type, + candidate->convs[1]->type); + else + inform (cloc, "%s%D(%T) <built-in>", msg, candidate->fn, + candidate->convs[0]->type); + } + else if (TYPE_P (candidate->fn)) + inform (cloc, "%s%T <conversion>", msg, candidate->fn); + else if (candidate->viable == -1) + inform (cloc, "%s%#D <near match>", msg, candidate->fn); + else if (DECL_DELETED_FN (candidate->fn)) + inform (cloc, "%s%#D <deleted>", msg, candidate->fn); + else + inform (cloc, "%s%#D", msg, candidate->fn); + /* Give the user some information about why this candidate failed. */ + if (candidate->reason != NULL) + { + struct rejection_reason *r = candidate->reason; + + switch (r->code) + { + case rr_arity: + print_arity_information (cloc, r->u.arity.actual, + r->u.arity.expected); + break; + case rr_arg_conversion: + print_conversion_rejection (cloc, &r->u.conversion); + break; + case rr_bad_arg_conversion: + print_conversion_rejection (cloc, &r->u.bad_conversion); + break; + case rr_explicit_conversion: + inform (cloc, " return type %qT of explicit conversion function " + "cannot be converted to %qT with a qualification " + "conversion", r->u.conversion.from_type, + r->u.conversion.to_type); + break; + case rr_template_conversion: + inform (cloc, " conversion from return type %qT of template " + "conversion function specialization to %qT is not an " + "exact match", r->u.conversion.from_type, + r->u.conversion.to_type); + break; + case rr_template_unification: + /* We use template_unification_error_rejection if unification caused + actual non-SFINAE errors, in which case we don't need to repeat + them here. */ + if (r->u.template_unification.tmpl == NULL_TREE) + { + inform (cloc, " substitution of deduced template arguments " + "resulted in errors seen above"); + break; + } + /* Re-run template unification with diagnostics. */ + inform (cloc, " template argument deduction/substitution failed:"); + fn_type_unification (r->u.template_unification.tmpl, + r->u.template_unification.explicit_targs, + (make_tree_vec + (r->u.template_unification.num_targs)), + r->u.template_unification.args, + r->u.template_unification.nargs, + r->u.template_unification.return_type, + r->u.template_unification.strict, + r->u.template_unification.flags, + true, false); + break; + case rr_invalid_copy: + inform (cloc, + " a constructor taking a single argument of its own " + "class type is invalid"); + break; + case rr_none: + default: + /* This candidate didn't have any issues or we failed to + handle a particular code. Either way... */ + gcc_unreachable (); + } + } +} + +static void +print_z_candidates (location_t loc, struct z_candidate *candidates) +{ + struct z_candidate *cand1; + struct z_candidate **cand2; + int n_candidates; + + if (!candidates) + return; + + /* Remove non-viable deleted candidates. */ + cand1 = candidates; + for (cand2 = &cand1; *cand2; ) + { + if (TREE_CODE ((*cand2)->fn) == FUNCTION_DECL + && !(*cand2)->viable + && DECL_DELETED_FN ((*cand2)->fn)) + *cand2 = (*cand2)->next; + else + cand2 = &(*cand2)->next; + } + /* ...if there are any non-deleted ones. */ + if (cand1) + candidates = cand1; + + /* There may be duplicates in the set of candidates. We put off + checking this condition as long as possible, since we have no way + to eliminate duplicates from a set of functions in less than n^2 + time. Now we are about to emit an error message, so it is more + permissible to go slowly. */ + for (cand1 = candidates; cand1; cand1 = cand1->next) + { + tree fn = cand1->fn; + /* Skip builtin candidates and conversion functions. */ + if (!DECL_P (fn)) + continue; + cand2 = &cand1->next; + while (*cand2) + { + if (DECL_P ((*cand2)->fn) + && equal_functions (fn, (*cand2)->fn)) + *cand2 = (*cand2)->next; + else + cand2 = &(*cand2)->next; + } + } + + for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next) + n_candidates++; + + inform_n (loc, n_candidates, "candidate is:", "candidates are:"); + for (; candidates; candidates = candidates->next) + print_z_candidate (loc, NULL, candidates); +} + +/* USER_SEQ is a user-defined conversion sequence, beginning with a + USER_CONV. STD_SEQ is the standard conversion sequence applied to + the result of the conversion function to convert it to the final + desired type. Merge the two sequences into a single sequence, + and return the merged sequence. */ + +static conversion * +merge_conversion_sequences (conversion *user_seq, conversion *std_seq) +{ + conversion **t; + bool bad = user_seq->bad_p; + + gcc_assert (user_seq->kind == ck_user); + + /* Find the end of the second conversion sequence. */ + for (t = &std_seq; (*t)->kind != ck_identity; t = &((*t)->u.next)) + { + /* The entire sequence is a user-conversion sequence. */ + (*t)->user_conv_p = true; + if (bad) + (*t)->bad_p = true; + } + + /* Replace the identity conversion with the user conversion + sequence. */ + *t = user_seq; + + return std_seq; +} + +/* Handle overload resolution for initializing an object of class type from + an initializer list. First we look for a suitable constructor that + takes a std::initializer_list; if we don't find one, we then look for a + non-list constructor. + + Parameters are as for add_candidates, except that the arguments are in + the form of a CONSTRUCTOR (the initializer list) rather than a vector, and + the RETURN_TYPE parameter is replaced by TOTYPE, the desired type. */ + +static void +add_list_candidates (tree fns, tree first_arg, + tree init_list, tree totype, + tree explicit_targs, bool template_only, + tree conversion_path, tree access_path, + int flags, + struct z_candidate **candidates, + tsubst_flags_t complain) +{ + vec<tree, va_gc> *args; + + gcc_assert (*candidates == NULL); + + /* We're looking for a ctor for list-initialization. */ + flags |= LOOKUP_LIST_INIT_CTOR; + /* And we don't allow narrowing conversions. We also use this flag to + avoid the copy constructor call for copy-list-initialization. */ + flags |= LOOKUP_NO_NARROWING; + + /* Always use the default constructor if the list is empty (DR 990). */ + if (CONSTRUCTOR_NELTS (init_list) == 0 + && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype)) + ; + /* If the class has a list ctor, try passing the list as a single + argument first, but only consider list ctors. */ + else if (TYPE_HAS_LIST_CTOR (totype)) + { + flags |= LOOKUP_LIST_ONLY; + args = make_tree_vector_single (init_list); + add_candidates (fns, first_arg, args, NULL_TREE, + explicit_targs, template_only, conversion_path, + access_path, flags, candidates, complain); + if (any_strictly_viable (*candidates)) + return; + } + + args = ctor_to_vec (init_list); + + /* We aren't looking for list-ctors anymore. */ + flags &= ~LOOKUP_LIST_ONLY; + /* We allow more user-defined conversions within an init-list. */ + flags &= ~LOOKUP_NO_CONVERSION; + + add_candidates (fns, first_arg, args, NULL_TREE, + explicit_targs, template_only, conversion_path, + access_path, flags, candidates, complain); +} + +/* Returns the best overload candidate to perform the requested + conversion. This function is used for three the overloading situations + described in [over.match.copy], [over.match.conv], and [over.match.ref]. + If TOTYPE is a REFERENCE_TYPE, we're trying to find a direct binding as + per [dcl.init.ref], so we ignore temporary bindings. */ + +static struct z_candidate * +build_user_type_conversion_1 (tree totype, tree expr, int flags, + tsubst_flags_t complain) +{ + struct z_candidate *candidates, *cand; + tree fromtype; + tree ctors = NULL_TREE; + tree conv_fns = NULL_TREE; + conversion *conv = NULL; + tree first_arg = NULL_TREE; + vec<tree, va_gc> *args = NULL; + bool any_viable_p; + int convflags; + + if (!expr) + return NULL; + + fromtype = TREE_TYPE (expr); + + /* We represent conversion within a hierarchy using RVALUE_CONV and + BASE_CONV, as specified by [over.best.ics]; these become plain + constructor calls, as specified in [dcl.init]. */ + gcc_assert (!MAYBE_CLASS_TYPE_P (fromtype) || !MAYBE_CLASS_TYPE_P (totype) + || !DERIVED_FROM_P (totype, fromtype)); + + if (MAYBE_CLASS_TYPE_P (totype)) + /* Use lookup_fnfields_slot instead of lookup_fnfields to avoid + creating a garbage BASELINK; constructors can't be inherited. */ + ctors = lookup_fnfields_slot (totype, complete_ctor_identifier); + + if (MAYBE_CLASS_TYPE_P (fromtype)) + { + tree to_nonref = non_reference (totype); + if (same_type_ignoring_top_level_qualifiers_p (to_nonref, fromtype) || + (CLASS_TYPE_P (to_nonref) && CLASS_TYPE_P (fromtype) + && DERIVED_FROM_P (to_nonref, fromtype))) + { + /* [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 + conv_fns = lookup_conversions (fromtype); + } + + candidates = 0; + flags |= LOOKUP_NO_CONVERSION; + if (BRACE_ENCLOSED_INITIALIZER_P (expr)) + flags |= LOOKUP_NO_NARROWING; + + /* It's OK to bind a temporary for converting constructor arguments, but + not in converting the return value of a conversion operator. */ + convflags = ((flags & LOOKUP_NO_TEMP_BIND) | LOOKUP_NO_CONVERSION); + flags &= ~LOOKUP_NO_TEMP_BIND; + + if (ctors) + { + int ctorflags = flags; + + first_arg = build_int_cst (build_pointer_type (totype), 0); + first_arg = build_fold_indirect_ref (first_arg); + + /* We should never try to call the abstract or base constructor + from here. */ + gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (OVL_CURRENT (ctors)) + && !DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors))); + + if (BRACE_ENCLOSED_INITIALIZER_P (expr)) + { + /* List-initialization. */ + add_list_candidates (ctors, first_arg, expr, totype, NULL_TREE, + false, TYPE_BINFO (totype), TYPE_BINFO (totype), + ctorflags, &candidates, complain); + } + else + { + args = make_tree_vector_single (expr); + add_candidates (ctors, first_arg, args, NULL_TREE, NULL_TREE, false, + TYPE_BINFO (totype), TYPE_BINFO (totype), + ctorflags, &candidates, complain); + } + + for (cand = candidates; cand; cand = cand->next) + { + cand->second_conv = build_identity_conv (totype, NULL_TREE); + + /* If totype isn't a reference, and LOOKUP_NO_TEMP_BIND isn't + set, then this is copy-initialization. In that case, "The + result of the call is then used to direct-initialize the + object that is the destination of the copy-initialization." + [dcl.init] + + We represent this in the conversion sequence with an + rvalue conversion, which means a constructor call. */ + if (TREE_CODE (totype) != REFERENCE_TYPE + && !(convflags & LOOKUP_NO_TEMP_BIND)) + cand->second_conv + = build_conv (ck_rvalue, totype, cand->second_conv); + } + } + + if (conv_fns) + first_arg = expr; + + for (; conv_fns; conv_fns = TREE_CHAIN (conv_fns)) + { + tree conversion_path = TREE_PURPOSE (conv_fns); + struct z_candidate *old_candidates; + + /* If we are called to convert to a reference type, we are trying to + find a direct binding, so don't even consider temporaries. If + we don't find a direct binding, the caller will try again to + look for a temporary binding. */ + if (TREE_CODE (totype) == REFERENCE_TYPE) + convflags |= LOOKUP_NO_TEMP_BIND; + + old_candidates = candidates; + add_candidates (TREE_VALUE (conv_fns), first_arg, NULL, totype, + NULL_TREE, false, + conversion_path, TYPE_BINFO (fromtype), + flags, &candidates, complain); + + for (cand = candidates; cand != old_candidates; cand = cand->next) + { + tree rettype = TREE_TYPE (TREE_TYPE (cand->fn)); + conversion *ics + = implicit_conversion (totype, + rettype, + 0, + /*c_cast_p=*/false, convflags, + complain); + + /* If LOOKUP_NO_TEMP_BIND isn't set, then this is + copy-initialization. In that case, "The result of the + call is then used to direct-initialize the object that is + the destination of the copy-initialization." [dcl.init] + + We represent this in the conversion sequence with an + rvalue conversion, which means a constructor call. But + don't add a second rvalue conversion if there's already + one there. Which there really shouldn't be, but it's + harmless since we'd add it here anyway. */ + if (ics && MAYBE_CLASS_TYPE_P (totype) && ics->kind != ck_rvalue + && !(convflags & LOOKUP_NO_TEMP_BIND)) + ics = build_conv (ck_rvalue, totype, ics); + + cand->second_conv = ics; + + if (!ics) + { + cand->viable = 0; + cand->reason = arg_conversion_rejection (NULL_TREE, -2, + rettype, totype); + } + else if (DECL_NONCONVERTING_P (cand->fn) + && ics->rank > cr_exact) + { + /* 13.3.1.5: For direct-initialization, those explicit + conversion functions that are not hidden within S and + yield type T or a type that can be converted to type T + with a qualification conversion (4.4) are also candidate + functions. */ + /* 13.3.1.6 doesn't have a parallel restriction, but it should; + I've raised this issue with the committee. --jason 9/2011 */ + cand->viable = -1; + cand->reason = explicit_conversion_rejection (rettype, totype); + } + else if (cand->viable == 1 && ics->bad_p) + { + cand->viable = -1; + cand->reason + = bad_arg_conversion_rejection (NULL_TREE, -2, + rettype, totype); + } + else if (primary_template_instantiation_p (cand->fn) + && ics->rank > cr_exact) + { + /* 13.3.3.1.2: If the user-defined conversion is specified by + a specialization of a conversion function template, the + second standard conversion sequence shall have exact match + rank. */ + cand->viable = -1; + cand->reason = template_conversion_rejection (rettype, totype); + } + } + } + + candidates = splice_viable (candidates, pedantic, &any_viable_p); + if (!any_viable_p) + { + if (args) + release_tree_vector (args); + return NULL; + } + + cand = tourney (candidates, complain); + if (cand == 0) + { + if (complain & tf_error) + { + error ("conversion from %qT to %qT is ambiguous", + fromtype, totype); + print_z_candidates (location_of (expr), candidates); + } + + cand = candidates; /* any one will do */ + cand->second_conv = build_ambiguous_conv (totype, expr); + cand->second_conv->user_conv_p = true; + if (!any_strictly_viable (candidates)) + cand->second_conv->bad_p = true; + /* If there are viable candidates, don't set ICS_BAD_FLAG; an + ambiguous conversion is no worse than another user-defined + conversion. */ + + return cand; + } + + /* Build the user conversion sequence. */ + conv = build_conv + (ck_user, + (DECL_CONSTRUCTOR_P (cand->fn) + ? totype : non_reference (TREE_TYPE (TREE_TYPE (cand->fn)))), + build_identity_conv (TREE_TYPE (expr), expr)); + conv->cand = cand; + if (cand->viable == -1) + conv->bad_p = true; + + /* Remember that this was a list-initialization. */ + if (flags & LOOKUP_NO_NARROWING) + conv->check_narrowing = true; + + /* Combine it with the second conversion sequence. */ + cand->second_conv = merge_conversion_sequences (conv, + cand->second_conv); + + return cand; +} + +/* Wrapper for above. */ + +tree +build_user_type_conversion (tree totype, tree expr, int flags, + tsubst_flags_t complain) +{ + struct z_candidate *cand; + tree ret; + + bool subtime = timevar_cond_start (TV_OVERLOAD); + cand = build_user_type_conversion_1 (totype, expr, flags, complain); + + if (cand) + { + if (cand->second_conv->kind == ck_ambig) + ret = error_mark_node; + else + { + expr = convert_like (cand->second_conv, expr, complain); + ret = convert_from_reference (expr); + } + } + else + ret = NULL_TREE; + + timevar_cond_stop (TV_OVERLOAD, subtime); + return ret; +} + +/* Subroutine of convert_nontype_argument. + + EXPR is an argument for a template non-type parameter of integral or + enumeration type. Do any necessary conversions (that are permitted for + non-type arguments) to convert it to the parameter type. + + If conversion is successful, returns the converted expression; + otherwise, returns error_mark_node. */ + +tree +build_integral_nontype_arg_conv (tree type, tree expr, tsubst_flags_t complain) +{ + conversion *conv; + void *p; + tree t; + location_t loc = EXPR_LOC_OR_LOC (expr, input_location); + + if (error_operand_p (expr)) + return error_mark_node; + + gcc_assert (INTEGRAL_OR_ENUMERATION_TYPE_P (type)); + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + conv = implicit_conversion (type, TREE_TYPE (expr), expr, + /*c_cast_p=*/false, + LOOKUP_IMPLICIT, complain); + + /* for a non-type template-parameter of integral or + enumeration type, integral promotions (4.5) and integral + conversions (4.7) are applied. */ + /* It should be sufficient to check the outermost conversion step, since + there are no qualification conversions to integer type. */ + if (conv) + switch (conv->kind) + { + /* A conversion function is OK. If it isn't constexpr, we'll + complain later that the argument isn't constant. */ + case ck_user: + /* The lvalue-to-rvalue conversion is OK. */ + case ck_rvalue: + case ck_identity: + break; + + case ck_std: + t = next_conversion (conv)->type; + if (INTEGRAL_OR_ENUMERATION_TYPE_P (t)) + break; + + if (complain & tf_error) + error_at (loc, "conversion from %qT to %qT not considered for " + "non-type template argument", t, type); + /* and fall through. */ + + default: + conv = NULL; + break; + } + + if (conv) + expr = convert_like (conv, expr, complain); + else + expr = error_mark_node; + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return expr; +} + +/* Do any initial processing on the arguments to a function call. */ + +static vec<tree, va_gc> * +resolve_args (vec<tree, va_gc> *args, tsubst_flags_t complain) +{ + unsigned int ix; + tree arg; + + FOR_EACH_VEC_SAFE_ELT (args, ix, arg) + { + if (error_operand_p (arg)) + return NULL; + else if (VOID_TYPE_P (TREE_TYPE (arg))) + { + if (complain & tf_error) + error ("invalid use of void expression"); + return NULL; + } + else if (invalid_nonstatic_memfn_p (arg, complain)) + return NULL; + } + return args; +} + +/* Perform overload resolution on FN, which is called with the ARGS. + + Return the candidate function selected by overload resolution, or + NULL if the event that overload resolution failed. In the case + that overload resolution fails, *CANDIDATES will be the set of + candidates considered, and ANY_VIABLE_P will be set to true or + false to indicate whether or not any of the candidates were + viable. + + The ARGS should already have gone through RESOLVE_ARGS before this + function is called. */ + +static struct z_candidate * +perform_overload_resolution (tree fn, + const vec<tree, va_gc> *args, + struct z_candidate **candidates, + bool *any_viable_p, tsubst_flags_t complain) +{ + struct z_candidate *cand; + tree explicit_targs; + int template_only; + + bool subtime = timevar_cond_start (TV_OVERLOAD); + + explicit_targs = NULL_TREE; + template_only = 0; + + *candidates = NULL; + *any_viable_p = true; + + /* Check FN. */ + gcc_assert (TREE_CODE (fn) == FUNCTION_DECL + || TREE_CODE (fn) == TEMPLATE_DECL + || TREE_CODE (fn) == OVERLOAD + || TREE_CODE (fn) == TEMPLATE_ID_EXPR); + + if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) + { + explicit_targs = TREE_OPERAND (fn, 1); + fn = TREE_OPERAND (fn, 0); + template_only = 1; + } + + /* Add the various candidate functions. */ + add_candidates (fn, NULL_TREE, args, NULL_TREE, + explicit_targs, template_only, + /*conversion_path=*/NULL_TREE, + /*access_path=*/NULL_TREE, + LOOKUP_NORMAL, + candidates, complain); + + *candidates = splice_viable (*candidates, pedantic, any_viable_p); + if (*any_viable_p) + cand = tourney (*candidates, complain); + else + cand = NULL; + + timevar_cond_stop (TV_OVERLOAD, subtime); + return cand; +} + +/* Print an error message about being unable to build a call to FN with + ARGS. ANY_VIABLE_P indicates whether any candidate functions could + be located; CANDIDATES is a possibly empty list of such + functions. */ + +static void +print_error_for_call_failure (tree fn, vec<tree, va_gc> *args, bool any_viable_p, + struct z_candidate *candidates) +{ + tree name = DECL_NAME (OVL_CURRENT (fn)); + location_t loc = location_of (name); + + if (!any_viable_p) + error_at (loc, "no matching function for call to %<%D(%A)%>", + name, build_tree_list_vec (args)); + else + error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous", + name, build_tree_list_vec (args)); + if (candidates) + print_z_candidates (loc, candidates); +} + +/* Return an expression for a call to FN (a namespace-scope function, + or a static member function) with the ARGS. This may change + ARGS. */ + +tree +build_new_function_call (tree fn, vec<tree, va_gc> **args, bool koenig_p, + tsubst_flags_t complain) +{ + struct z_candidate *candidates, *cand; + bool any_viable_p; + void *p; + tree result; + + if (args != NULL && *args != NULL) + { + *args = resolve_args (*args, complain); + if (*args == NULL) + return error_mark_node; + } + + if (flag_tm) + tm_malloc_replacement (fn); + + /* If this function was found without using argument dependent + lookup, then we want to ignore any undeclared friend + functions. */ + if (!koenig_p) + { + tree orig_fn = fn; + + fn = remove_hidden_names (fn); + if (!fn) + { + if (complain & tf_error) + print_error_for_call_failure (orig_fn, *args, false, NULL); + return error_mark_node; + } + } + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + cand = perform_overload_resolution (fn, *args, &candidates, &any_viable_p, + complain); + + if (!cand) + { + if (complain & tf_error) + { + if (!any_viable_p && candidates && ! candidates->next + && (TREE_CODE (candidates->fn) == FUNCTION_DECL)) + return cp_build_function_call_vec (candidates->fn, args, complain); + if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) + fn = TREE_OPERAND (fn, 0); + print_error_for_call_failure (fn, *args, any_viable_p, candidates); + } + result = error_mark_node; + } + else + { + int flags = LOOKUP_NORMAL; + /* If fn is template_id_expr, the call has explicit template arguments + (e.g. func<int>(5)), communicate this info to build_over_call + through flags so that later we can use it to decide whether to warn + about peculiar null pointer conversion. */ + if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) + flags |= LOOKUP_EXPLICIT_TMPL_ARGS; + result = build_over_call (cand, flags, complain); + } + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return result; +} + +/* Build a call to a global operator new. FNNAME is the name of the + operator (either "operator new" or "operator new[]") and ARGS are + the arguments provided. This may change ARGS. *SIZE points to the + total number of bytes required by the allocation, and is updated if + that is changed here. *COOKIE_SIZE is non-NULL if a cookie should + be used. If this function determines that no cookie should be + used, after all, *COOKIE_SIZE is set to NULL_TREE. If SIZE_CHECK + is not NULL_TREE, it is evaluated before calculating the final + array size, and if it fails, the array size is replaced with + (size_t)-1 (usually triggering a std::bad_alloc exception). If FN + is non-NULL, it will be set, upon return, to the allocation + function called. */ + +tree +build_operator_new_call (tree fnname, vec<tree, va_gc> **args, + tree *size, tree *cookie_size, tree size_check, + tree *fn, tsubst_flags_t complain) +{ + tree original_size = *size; + tree fns; + struct z_candidate *candidates; + struct z_candidate *cand; + bool any_viable_p; + + if (fn) + *fn = NULL_TREE; + /* Set to (size_t)-1 if the size check fails. */ + if (size_check != NULL_TREE) + { + tree errval = TYPE_MAX_VALUE (sizetype); + if (cxx_dialect >= cxx11 && flag_exceptions) + errval = throw_bad_array_new_length (); + *size = fold_build3 (COND_EXPR, sizetype, size_check, + original_size, errval); + } + vec_safe_insert (*args, 0, *size); + *args = resolve_args (*args, complain); + if (*args == NULL) + return error_mark_node; + + /* Based on: + + [expr.new] + + If this lookup fails to find the name, or if the allocated type + is not a class type, the allocation function's name is looked + up in the global scope. + + we disregard block-scope declarations of "operator new". */ + fns = lookup_function_nonclass (fnname, *args, /*block_p=*/false); + + /* Figure out what function is being called. */ + cand = perform_overload_resolution (fns, *args, &candidates, &any_viable_p, + complain); + + /* If no suitable function could be found, issue an error message + and give up. */ + if (!cand) + { + if (complain & tf_error) + print_error_for_call_failure (fns, *args, any_viable_p, candidates); + return error_mark_node; + } + + /* If a cookie is required, add some extra space. Whether + or not a cookie is required cannot be determined until + after we know which function was called. */ + if (*cookie_size) + { + bool use_cookie = true; + if (!abi_version_at_least (2)) + { + /* In G++ 3.2, the check was implemented incorrectly; it + looked at the placement expression, rather than the + type of the function. */ + if ((*args)->length () == 2 + && same_type_p (TREE_TYPE ((**args)[1]), ptr_type_node)) + use_cookie = false; + } + else + { + tree arg_types; + + arg_types = TYPE_ARG_TYPES (TREE_TYPE (cand->fn)); + /* Skip the size_t parameter. */ + arg_types = TREE_CHAIN (arg_types); + /* Check the remaining parameters (if any). */ + if (arg_types + && TREE_CHAIN (arg_types) == void_list_node + && same_type_p (TREE_VALUE (arg_types), + ptr_type_node)) + use_cookie = false; + } + /* If we need a cookie, adjust the number of bytes allocated. */ + if (use_cookie) + { + /* Update the total size. */ + *size = size_binop (PLUS_EXPR, original_size, *cookie_size); + /* Set to (size_t)-1 if the size check fails. */ + gcc_assert (size_check != NULL_TREE); + *size = fold_build3 (COND_EXPR, sizetype, size_check, + *size, TYPE_MAX_VALUE (sizetype)); + /* Update the argument list to reflect the adjusted size. */ + (**args)[0] = *size; + } + else + *cookie_size = NULL_TREE; + } + + /* Tell our caller which function we decided to call. */ + if (fn) + *fn = cand->fn; + + /* Build the CALL_EXPR. */ + return build_over_call (cand, LOOKUP_NORMAL, complain); +} + +/* Build a new call to operator(). This may change ARGS. */ + +static tree +build_op_call_1 (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain) +{ + struct z_candidate *candidates = 0, *cand; + tree fns, convs, first_mem_arg = NULL_TREE; + tree type = TREE_TYPE (obj); + bool any_viable_p; + tree result = NULL_TREE; + void *p; + + if (error_operand_p (obj)) + return error_mark_node; + + obj = prep_operand (obj); + + if (TYPE_PTRMEMFUNC_P (type)) + { + if (complain & tf_error) + /* It's no good looking for an overloaded operator() on a + pointer-to-member-function. */ + error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj); + return error_mark_node; + } + + if (TYPE_BINFO (type)) + { + fns = lookup_fnfields (TYPE_BINFO (type), ansi_opname (CALL_EXPR), 1); + if (fns == error_mark_node) + return error_mark_node; + } + else + fns = NULL_TREE; + + if (args != NULL && *args != NULL) + { + *args = resolve_args (*args, complain); + if (*args == NULL) + return error_mark_node; + } + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + if (fns) + { + first_mem_arg = obj; + + add_candidates (BASELINK_FUNCTIONS (fns), + first_mem_arg, *args, NULL_TREE, + NULL_TREE, false, + BASELINK_BINFO (fns), BASELINK_ACCESS_BINFO (fns), + LOOKUP_NORMAL, &candidates, complain); + } + + convs = lookup_conversions (type); + + for (; convs; convs = TREE_CHAIN (convs)) + { + tree fns = TREE_VALUE (convs); + tree totype = TREE_TYPE (convs); + + if (TYPE_PTRFN_P (totype) + || TYPE_REFFN_P (totype) + || (TREE_CODE (totype) == REFERENCE_TYPE + && TYPE_PTRFN_P (TREE_TYPE (totype)))) + for (; fns; fns = OVL_NEXT (fns)) + { + tree fn = OVL_CURRENT (fns); + + if (DECL_NONCONVERTING_P (fn)) + continue; + + if (TREE_CODE (fn) == TEMPLATE_DECL) + add_template_conv_candidate + (&candidates, fn, obj, NULL_TREE, *args, totype, + /*access_path=*/NULL_TREE, + /*conversion_path=*/NULL_TREE, complain); + else + add_conv_candidate (&candidates, fn, obj, NULL_TREE, + *args, /*conversion_path=*/NULL_TREE, + /*access_path=*/NULL_TREE, complain); + } + } + + candidates = splice_viable (candidates, pedantic, &any_viable_p); + if (!any_viable_p) + { + if (complain & tf_error) + { + error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), + build_tree_list_vec (*args)); + print_z_candidates (location_of (TREE_TYPE (obj)), candidates); + } + result = error_mark_node; + } + else + { + cand = tourney (candidates, complain); + if (cand == 0) + { + if (complain & tf_error) + { + error ("call of %<(%T) (%A)%> is ambiguous", + TREE_TYPE (obj), build_tree_list_vec (*args)); + print_z_candidates (location_of (TREE_TYPE (obj)), candidates); + } + result = error_mark_node; + } + /* Since cand->fn will be a type, not a function, for a conversion + function, we must be careful not to unconditionally look at + DECL_NAME here. */ + else if (TREE_CODE (cand->fn) == FUNCTION_DECL + && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR) + result = build_over_call (cand, LOOKUP_NORMAL, complain); + else + { + obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1, + complain); + obj = convert_from_reference (obj); + result = cp_build_function_call_vec (obj, args, complain); + } + } + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return result; +} + +/* Wrapper for above. */ + +tree +build_op_call (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain) +{ + tree ret; + bool subtime = timevar_cond_start (TV_OVERLOAD); + ret = build_op_call_1 (obj, args, complain); + timevar_cond_stop (TV_OVERLOAD, subtime); + return ret; +} + +/* Called by op_error to prepare format strings suitable for the error + function. It concatenates a prefix (controlled by MATCH), ERRMSG, + and a suffix (controlled by NTYPES). */ + +static const char * +op_error_string (const char *errmsg, int ntypes, bool match) +{ + const char *msg; + + const char *msgp = concat (match ? G_("ambiguous overload for ") + : G_("no match for "), errmsg, NULL); + + if (ntypes == 3) + msg = concat (msgp, G_(" (operand types are %qT, %qT, and %qT)"), NULL); + else if (ntypes == 2) + msg = concat (msgp, G_(" (operand types are %qT and %qT)"), NULL); + else + msg = concat (msgp, G_(" (operand type is %qT)"), NULL); + + return msg; +} + +static void +op_error (location_t loc, enum tree_code code, enum tree_code code2, + tree arg1, tree arg2, tree arg3, bool match) +{ + const char *opname; + + if (code == MODIFY_EXPR) + opname = assignment_operator_name_info[code2].name; + else + opname = operator_name_info[code].name; + + switch (code) + { + case COND_EXPR: + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("ternary %<operator?:%>"), + 3, match), + TREE_TYPE (arg1), TREE_TYPE (arg2), TREE_TYPE (arg3)); + else + error_at (loc, op_error_string (G_("ternary %<operator?:%> " + "in %<%E ? %E : %E%>"), 3, match), + arg1, arg2, arg3, + TREE_TYPE (arg1), TREE_TYPE (arg2), TREE_TYPE (arg3)); + break; + + case POSTINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("%<operator%s%>"), 1, match), + opname, TREE_TYPE (arg1)); + else + error_at (loc, op_error_string (G_("%<operator%s%> in %<%E%s%>"), + 1, match), + opname, arg1, opname, TREE_TYPE (arg1)); + break; + + case ARRAY_REF: + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("%<operator[]%>"), 2, match), + TREE_TYPE (arg1), TREE_TYPE (arg2)); + else + error_at (loc, op_error_string (G_("%<operator[]%> in %<%E[%E]%>"), + 2, match), + arg1, arg2, TREE_TYPE (arg1), TREE_TYPE (arg2)); + break; + + case REALPART_EXPR: + case IMAGPART_EXPR: + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("%qs"), 1, match), + opname, TREE_TYPE (arg1)); + else + error_at (loc, op_error_string (G_("%qs in %<%s %E%>"), 1, match), + opname, opname, arg1, TREE_TYPE (arg1)); + break; + + default: + if (arg2) + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("%<operator%s%>"), 2, match), + opname, TREE_TYPE (arg1), TREE_TYPE (arg2)); + else + error_at (loc, op_error_string (G_("%<operator%s%> in %<%E %s %E%>"), + 2, match), + opname, arg1, opname, arg2, + TREE_TYPE (arg1), TREE_TYPE (arg2)); + else + if (flag_diagnostics_show_caret) + error_at (loc, op_error_string (G_("%<operator%s%>"), 1, match), + opname, TREE_TYPE (arg1)); + else + error_at (loc, op_error_string (G_("%<operator%s%> in %<%s%E%>"), + 1, match), + opname, opname, arg1, TREE_TYPE (arg1)); + break; + } +} + +/* Return the implicit conversion sequence that could be used to + convert E1 to E2 in [expr.cond]. */ + +static conversion * +conditional_conversion (tree e1, tree e2, tsubst_flags_t complain) +{ + tree t1 = non_reference (TREE_TYPE (e1)); + tree t2 = non_reference (TREE_TYPE (e2)); + conversion *conv; + bool good_base; + + /* [expr.cond] + + If E2 is an lvalue: E1 can be converted to match E2 if E1 can be + implicitly converted (clause _conv_) to the type "lvalue reference to + T2", subject to the constraint that in the conversion the + reference must bind directly (_dcl.init.ref_) to an lvalue. */ + if (real_lvalue_p (e2)) + { + conv = implicit_conversion (build_reference_type (t2), + t1, + e1, + /*c_cast_p=*/false, + LOOKUP_NO_TEMP_BIND|LOOKUP_NO_RVAL_BIND + |LOOKUP_ONLYCONVERTING, + complain); + if (conv) + return conv; + } + + /* [expr.cond] + + If E1 and E2 have class type, and the underlying class types are + the same or one is a base class of the other: E1 can be converted + to match E2 if the class of T2 is the same type as, or a base + class of, the class of T1, and the cv-qualification of T2 is the + same cv-qualification as, or a greater cv-qualification than, the + cv-qualification of T1. If the conversion is applied, E1 is + changed to an rvalue of type T2 that still refers to the original + source class object (or the appropriate subobject thereof). */ + if (CLASS_TYPE_P (t1) && CLASS_TYPE_P (t2) + && ((good_base = DERIVED_FROM_P (t2, t1)) || DERIVED_FROM_P (t1, t2))) + { + if (good_base && at_least_as_qualified_p (t2, t1)) + { + conv = build_identity_conv (t1, e1); + if (!same_type_p (TYPE_MAIN_VARIANT (t1), + TYPE_MAIN_VARIANT (t2))) + conv = build_conv (ck_base, t2, conv); + else + conv = build_conv (ck_rvalue, t2, conv); + return conv; + } + else + return NULL; + } + else + /* [expr.cond] + + Otherwise: E1 can be converted to match E2 if E1 can be implicitly + converted to the type that expression E2 would have if E2 were + converted to an rvalue (or the type it has, if E2 is an rvalue). */ + return implicit_conversion (t2, t1, e1, /*c_cast_p=*/false, + LOOKUP_IMPLICIT, complain); +} + +/* Implement [expr.cond]. ARG1, ARG2, and ARG3 are the three + arguments to the conditional expression. */ + +static tree +build_conditional_expr_1 (location_t loc, tree arg1, tree arg2, tree arg3, + tsubst_flags_t complain) +{ + tree arg2_type; + tree arg3_type; + tree result = NULL_TREE; + tree result_type = NULL_TREE; + bool lvalue_p = true; + struct z_candidate *candidates = 0; + struct z_candidate *cand; + void *p; + tree orig_arg2, orig_arg3; + + /* As a G++ extension, the second argument to the conditional can be + omitted. (So that `a ? : c' is roughly equivalent to `a ? a : + c'.) If the second operand is omitted, make sure it is + calculated only once. */ + if (!arg2) + { + if (complain & tf_error) + pedwarn (loc, OPT_Wpedantic, + "ISO C++ forbids omitting the middle term of a ?: expression"); + + /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */ + if (real_lvalue_p (arg1)) + arg2 = arg1 = stabilize_reference (arg1); + else + arg2 = arg1 = save_expr (arg1); + } + + /* If something has already gone wrong, just pass that fact up the + tree. */ + if (error_operand_p (arg1) + || error_operand_p (arg2) + || error_operand_p (arg3)) + return error_mark_node; + + orig_arg2 = arg2; + orig_arg3 = arg3; + + if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (arg1))) + { + arg1 = force_rvalue (arg1, complain); + arg2 = force_rvalue (arg2, complain); + arg3 = force_rvalue (arg3, complain); + + /* force_rvalue can return error_mark on valid arguments. */ + if (error_operand_p (arg1) + || error_operand_p (arg2) + || error_operand_p (arg3)) + return error_mark_node; + + tree arg1_type = TREE_TYPE (arg1); + arg2_type = TREE_TYPE (arg2); + arg3_type = TREE_TYPE (arg3); + + if (TREE_CODE (arg2_type) != VECTOR_TYPE + && TREE_CODE (arg3_type) != VECTOR_TYPE) + { + /* Rely on the error messages of the scalar version. */ + tree scal = build_conditional_expr_1 (loc, integer_one_node, + orig_arg2, orig_arg3, complain); + if (scal == error_mark_node) + return error_mark_node; + tree stype = TREE_TYPE (scal); + tree ctype = TREE_TYPE (arg1_type); + if (TYPE_SIZE (stype) != TYPE_SIZE (ctype) + || (!INTEGRAL_TYPE_P (stype) && !SCALAR_FLOAT_TYPE_P (stype))) + { + if (complain & tf_error) + error_at (loc, "inferred scalar type %qT is not an integer or " + "floating point type of the same size as %qT", stype, + COMPARISON_CLASS_P (arg1) + ? TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg1, 0))) + : ctype); + return error_mark_node; + } + + tree vtype = build_opaque_vector_type (stype, + TYPE_VECTOR_SUBPARTS (arg1_type)); + /* We could pass complain & tf_warning to unsafe_conversion_p, + but the warnings (like Wsign-conversion) have already been + given by the scalar build_conditional_expr_1. We still check + unsafe_conversion_p to forbid truncating long long -> float. */ + if (unsafe_conversion_p (loc, stype, arg2, false)) + { + if (complain & tf_error) + error_at (loc, "conversion of scalar %qT to vector %qT " + "involves truncation", arg2_type, vtype); + return error_mark_node; + } + if (unsafe_conversion_p (loc, stype, arg3, false)) + { + if (complain & tf_error) + error_at (loc, "conversion of scalar %qT to vector %qT " + "involves truncation", arg3_type, vtype); + return error_mark_node; + } + + arg2 = cp_convert (stype, arg2, complain); + arg2 = save_expr (arg2); + arg2 = build_vector_from_val (vtype, arg2); + arg2_type = vtype; + arg3 = cp_convert (stype, arg3, complain); + arg3 = save_expr (arg3); + arg3 = build_vector_from_val (vtype, arg3); + arg3_type = vtype; + } + + if ((TREE_CODE (arg2_type) == VECTOR_TYPE) + != (TREE_CODE (arg3_type) == VECTOR_TYPE)) + { + enum stv_conv convert_flag = + scalar_to_vector (loc, VEC_COND_EXPR, arg2, arg3, + complain & tf_error); + + switch (convert_flag) + { + case stv_error: + return error_mark_node; + case stv_firstarg: + { + arg2 = save_expr (arg2); + arg2 = convert (TREE_TYPE (arg3_type), arg2); + arg2 = build_vector_from_val (arg3_type, arg2); + arg2_type = TREE_TYPE (arg2); + break; + } + case stv_secondarg: + { + arg3 = save_expr (arg3); + arg3 = convert (TREE_TYPE (arg2_type), arg3); + arg3 = build_vector_from_val (arg2_type, arg3); + arg3_type = TREE_TYPE (arg3); + break; + } + default: + break; + } + } + + if (!same_type_p (arg2_type, arg3_type) + || TYPE_VECTOR_SUBPARTS (arg1_type) + != TYPE_VECTOR_SUBPARTS (arg2_type) + || TYPE_SIZE (arg1_type) != TYPE_SIZE (arg2_type)) + { + if (complain & tf_error) + error_at (loc, + "incompatible vector types in conditional expression: " + "%qT, %qT and %qT", TREE_TYPE (arg1), + TREE_TYPE (orig_arg2), TREE_TYPE (orig_arg3)); + return error_mark_node; + } + + if (!COMPARISON_CLASS_P (arg1)) + arg1 = cp_build_binary_op (loc, NE_EXPR, arg1, + build_zero_cst (arg1_type), complain); + return fold_build3 (VEC_COND_EXPR, arg2_type, arg1, arg2, arg3); + } + + /* [expr.cond] + + The first expression is implicitly converted to bool (clause + _conv_). */ + arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain, + LOOKUP_NORMAL); + if (error_operand_p (arg1)) + return error_mark_node; + + /* [expr.cond] + + If either the second or the third operand has type (possibly + cv-qualified) void, then the lvalue-to-rvalue (_conv.lval_), + array-to-pointer (_conv.array_), and function-to-pointer + (_conv.func_) standard conversions are performed on the second + and third operands. */ + arg2_type = unlowered_expr_type (arg2); + arg3_type = unlowered_expr_type (arg3); + if (VOID_TYPE_P (arg2_type) || VOID_TYPE_P (arg3_type)) + { + /* Do the conversions. We don't these for `void' type arguments + since it can't have any effect and since decay_conversion + does not handle that case gracefully. */ + if (!VOID_TYPE_P (arg2_type)) + arg2 = decay_conversion (arg2, complain); + if (!VOID_TYPE_P (arg3_type)) + arg3 = decay_conversion (arg3, complain); + arg2_type = TREE_TYPE (arg2); + arg3_type = TREE_TYPE (arg3); + + /* [expr.cond] + + One of the following shall hold: + + --The second or the third operand (but not both) is a + throw-expression (_except.throw_); the result is of the + type of the other and is an rvalue. + + --Both the second and the third operands have type void; the + result is of type void and is an rvalue. + + We must avoid calling force_rvalue for expressions of type + "void" because it will complain that their value is being + used. */ + if (TREE_CODE (arg2) == THROW_EXPR + && TREE_CODE (arg3) != THROW_EXPR) + { + if (!VOID_TYPE_P (arg3_type)) + { + arg3 = force_rvalue (arg3, complain); + if (arg3 == error_mark_node) + return error_mark_node; + } + arg3_type = TREE_TYPE (arg3); + result_type = arg3_type; + } + else if (TREE_CODE (arg2) != THROW_EXPR + && TREE_CODE (arg3) == THROW_EXPR) + { + if (!VOID_TYPE_P (arg2_type)) + { + arg2 = force_rvalue (arg2, complain); + if (arg2 == error_mark_node) + return error_mark_node; + } + arg2_type = TREE_TYPE (arg2); + result_type = arg2_type; + } + else if (VOID_TYPE_P (arg2_type) && VOID_TYPE_P (arg3_type)) + result_type = void_type_node; + else + { + if (complain & tf_error) + { + if (VOID_TYPE_P (arg2_type)) + error_at (EXPR_LOC_OR_LOC (arg3, loc), + "second operand to the conditional operator " + "is of type %<void%>, but the third operand is " + "neither a throw-expression nor of type %<void%>"); + else + error_at (EXPR_LOC_OR_LOC (arg2, loc), + "third operand to the conditional operator " + "is of type %<void%>, but the second operand is " + "neither a throw-expression nor of type %<void%>"); + } + return error_mark_node; + } + + lvalue_p = false; + goto valid_operands; + } + /* [expr.cond] + + Otherwise, if the second and third operand have different types, + and either has (possibly cv-qualified) class type, an attempt is + made to convert each of those operands to the type of the other. */ + else if (!same_type_p (arg2_type, arg3_type) + && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) + { + conversion *conv2; + conversion *conv3; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + conv2 = conditional_conversion (arg2, arg3, complain); + conv3 = conditional_conversion (arg3, arg2, complain); + + /* [expr.cond] + + If both can be converted, or one can be converted but the + conversion is ambiguous, the program is ill-formed. If + neither can be converted, the operands are left unchanged and + further checking is performed as described below. If exactly + one conversion is possible, that conversion is applied to the + chosen operand and the converted operand is used in place of + the original operand for the remainder of this section. */ + if ((conv2 && !conv2->bad_p + && conv3 && !conv3->bad_p) + || (conv2 && conv2->kind == ck_ambig) + || (conv3 && conv3->kind == ck_ambig)) + { + if (complain & tf_error) + error_at (loc, "operands to ?: have different types %qT and %qT", + arg2_type, arg3_type); + result = error_mark_node; + } + else if (conv2 && (!conv2->bad_p || !conv3)) + { + arg2 = convert_like (conv2, arg2, complain); + arg2 = convert_from_reference (arg2); + arg2_type = TREE_TYPE (arg2); + /* Even if CONV2 is a valid conversion, the result of the + conversion may be invalid. For example, if ARG3 has type + "volatile X", and X does not have a copy constructor + accepting a "volatile X&", then even if ARG2 can be + converted to X, the conversion will fail. */ + if (error_operand_p (arg2)) + result = error_mark_node; + } + else if (conv3 && (!conv3->bad_p || !conv2)) + { + arg3 = convert_like (conv3, arg3, complain); + arg3 = convert_from_reference (arg3); + arg3_type = TREE_TYPE (arg3); + if (error_operand_p (arg3)) + result = error_mark_node; + } + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + if (result) + return result; + + /* If, after the conversion, both operands have class type, + treat the cv-qualification of both operands as if it were the + union of the cv-qualification of the operands. + + The standard is not clear about what to do in this + circumstance. For example, if the first operand has type + "const X" and the second operand has a user-defined + conversion to "volatile X", what is the type of the second + operand after this step? Making it be "const X" (matching + the first operand) seems wrong, as that discards the + qualification without actually performing a copy. Leaving it + as "volatile X" seems wrong as that will result in the + conditional expression failing altogether, even though, + according to this step, the one operand could be converted to + the type of the other. */ + if ((conv2 || conv3) + && CLASS_TYPE_P (arg2_type) + && cp_type_quals (arg2_type) != cp_type_quals (arg3_type)) + arg2_type = arg3_type = + cp_build_qualified_type (arg2_type, + cp_type_quals (arg2_type) + | cp_type_quals (arg3_type)); + } + + /* [expr.cond] + + If the second and third operands are glvalues of the same value + category and have the same type, the result is of that type and + value category. */ + if (((real_lvalue_p (arg2) && real_lvalue_p (arg3)) + || (xvalue_p (arg2) && xvalue_p (arg3))) + && same_type_p (arg2_type, arg3_type)) + { + result_type = arg2_type; + arg2 = mark_lvalue_use (arg2); + arg3 = mark_lvalue_use (arg3); + goto valid_operands; + } + + /* [expr.cond] + + Otherwise, the result is an rvalue. If the second and third + operand do not have the same type, and either has (possibly + cv-qualified) class type, overload resolution is used to + determine the conversions (if any) to be applied to the operands + (_over.match.oper_, _over.built_). */ + lvalue_p = false; + if (!same_type_p (arg2_type, arg3_type) + && (CLASS_TYPE_P (arg2_type) || CLASS_TYPE_P (arg3_type))) + { + tree args[3]; + conversion *conv; + bool any_viable_p; + + /* Rearrange the arguments so that add_builtin_candidate only has + to know about two args. In build_builtin_candidate, the + arguments are unscrambled. */ + args[0] = arg2; + args[1] = arg3; + args[2] = arg1; + add_builtin_candidates (&candidates, + COND_EXPR, + NOP_EXPR, + ansi_opname (COND_EXPR), + args, + LOOKUP_NORMAL, complain); + + /* [expr.cond] + + If the overload resolution fails, the program is + ill-formed. */ + candidates = splice_viable (candidates, pedantic, &any_viable_p); + if (!any_viable_p) + { + if (complain & tf_error) + { + op_error (loc, COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE); + print_z_candidates (loc, candidates); + } + return error_mark_node; + } + cand = tourney (candidates, complain); + if (!cand) + { + if (complain & tf_error) + { + op_error (loc, COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE); + print_z_candidates (loc, candidates); + } + return error_mark_node; + } + + /* [expr.cond] + + Otherwise, the conversions thus determined are applied, and + the converted operands are used in place of the original + operands for the remainder of this section. */ + conv = cand->convs[0]; + arg1 = convert_like (conv, arg1, complain); + conv = cand->convs[1]; + arg2 = convert_like (conv, arg2, complain); + arg2_type = TREE_TYPE (arg2); + conv = cand->convs[2]; + arg3 = convert_like (conv, arg3, complain); + arg3_type = TREE_TYPE (arg3); + } + + /* [expr.cond] + + Lvalue-to-rvalue (_conv.lval_), array-to-pointer (_conv.array_), + and function-to-pointer (_conv.func_) standard conversions are + performed on the second and third operands. + + We need to force the lvalue-to-rvalue conversion here for class types, + so we get TARGET_EXPRs; trying to deal with a COND_EXPR of class rvalues + that isn't wrapped with a TARGET_EXPR plays havoc with exception + regions. */ + + arg2 = force_rvalue (arg2, complain); + if (!CLASS_TYPE_P (arg2_type)) + arg2_type = TREE_TYPE (arg2); + + arg3 = force_rvalue (arg3, complain); + if (!CLASS_TYPE_P (arg3_type)) + arg3_type = TREE_TYPE (arg3); + + if (arg2 == error_mark_node || arg3 == error_mark_node) + return error_mark_node; + + /* [expr.cond] + + After those conversions, one of the following shall hold: + + --The second and third operands have the same type; the result is of + that type. */ + if (same_type_p (arg2_type, arg3_type)) + result_type = arg2_type; + /* [expr.cond] + + --The second and third operands have arithmetic or enumeration + type; the usual arithmetic conversions are performed to bring + them to a common type, and the result is of that type. */ + else if ((ARITHMETIC_TYPE_P (arg2_type) + || UNSCOPED_ENUM_P (arg2_type)) + && (ARITHMETIC_TYPE_P (arg3_type) + || UNSCOPED_ENUM_P (arg3_type))) + { + /* In this case, there is always a common type. */ + result_type = type_after_usual_arithmetic_conversions (arg2_type, + arg3_type); + if (complain & tf_warning) + do_warn_double_promotion (result_type, arg2_type, arg3_type, + "implicit conversion from %qT to %qT to " + "match other result of conditional", + loc); + + if (TREE_CODE (arg2_type) == ENUMERAL_TYPE + && TREE_CODE (arg3_type) == ENUMERAL_TYPE) + { + if (TREE_CODE (orig_arg2) == CONST_DECL + && TREE_CODE (orig_arg3) == CONST_DECL + && DECL_CONTEXT (orig_arg2) == DECL_CONTEXT (orig_arg3)) + /* Two enumerators from the same enumeration can have different + types when the enumeration is still being defined. */; + else if (complain & tf_warning) + warning_at (loc, OPT_Wenum_compare, "enumeral mismatch in " + "conditional expression: %qT vs %qT", + arg2_type, arg3_type); + } + else if (extra_warnings + && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE + && !same_type_p (arg3_type, type_promotes_to (arg2_type))) + || (TREE_CODE (arg3_type) == ENUMERAL_TYPE + && !same_type_p (arg2_type, + type_promotes_to (arg3_type))))) + { + if (complain & tf_warning) + warning_at (loc, 0, "enumeral and non-enumeral type in " + "conditional expression"); + } + + arg2 = perform_implicit_conversion (result_type, arg2, complain); + arg3 = perform_implicit_conversion (result_type, arg3, complain); + } + /* [expr.cond] + + --The second and third operands have pointer type, or one has + pointer type and the other is a null pointer constant; pointer + conversions (_conv.ptr_) and qualification conversions + (_conv.qual_) are performed to bring them to their composite + pointer type (_expr.rel_). The result is of the composite + pointer type. + + --The second and third operands have pointer to member type, or + one has pointer to member type and the other is a null pointer + constant; pointer to member conversions (_conv.mem_) and + qualification conversions (_conv.qual_) are performed to bring + them to a common type, whose cv-qualification shall match the + cv-qualification of either the second or the third operand. + The result is of the common type. */ + else if ((null_ptr_cst_p (arg2) + && TYPE_PTR_OR_PTRMEM_P (arg3_type)) + || (null_ptr_cst_p (arg3) + && TYPE_PTR_OR_PTRMEM_P (arg2_type)) + || (TYPE_PTR_P (arg2_type) && TYPE_PTR_P (arg3_type)) + || (TYPE_PTRDATAMEM_P (arg2_type) && TYPE_PTRDATAMEM_P (arg3_type)) + || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type))) + { + result_type = composite_pointer_type (arg2_type, arg3_type, arg2, + arg3, CPO_CONDITIONAL_EXPR, + complain); + if (result_type == error_mark_node) + return error_mark_node; + arg2 = perform_implicit_conversion (result_type, arg2, complain); + arg3 = perform_implicit_conversion (result_type, arg3, complain); + } + + if (!result_type) + { + if (complain & tf_error) + error_at (loc, "operands to ?: have different types %qT and %qT", + arg2_type, arg3_type); + return error_mark_node; + } + + if (arg2 == error_mark_node || arg3 == error_mark_node) + return error_mark_node; + + valid_operands: + result = build3 (COND_EXPR, result_type, arg1, arg2, arg3); + if (!cp_unevaluated_operand) + /* Avoid folding within decltype (c++/42013) and noexcept. */ + result = fold_if_not_in_template (result); + + /* We can't use result_type below, as fold might have returned a + throw_expr. */ + + if (!lvalue_p) + { + /* Expand both sides into the same slot, hopefully the target of + the ?: expression. We used to check for TARGET_EXPRs here, + but now we sometimes wrap them in NOP_EXPRs so the test would + fail. */ + if (CLASS_TYPE_P (TREE_TYPE (result))) + result = get_target_expr_sfinae (result, complain); + /* If this expression is an rvalue, but might be mistaken for an + lvalue, we must add a NON_LVALUE_EXPR. */ + result = rvalue (result); + } + else + result = force_paren_expr (result); + + return result; +} + +/* Wrapper for above. */ + +tree +build_conditional_expr (location_t loc, tree arg1, tree arg2, tree arg3, + tsubst_flags_t complain) +{ + tree ret; + bool subtime = timevar_cond_start (TV_OVERLOAD); + ret = build_conditional_expr_1 (loc, arg1, arg2, arg3, complain); + timevar_cond_stop (TV_OVERLOAD, subtime); + return ret; +} + +/* OPERAND is an operand to an expression. Perform necessary steps + required before using it. If OPERAND is NULL_TREE, NULL_TREE is + returned. */ + +static tree +prep_operand (tree operand) +{ + if (operand) + { + if (CLASS_TYPE_P (TREE_TYPE (operand)) + && CLASSTYPE_TEMPLATE_INSTANTIATION (TREE_TYPE (operand))) + /* Make sure the template type is instantiated now. */ + instantiate_class_template (TYPE_MAIN_VARIANT (TREE_TYPE (operand))); + } + + return operand; +} + +/* Add each of the viable functions in FNS (a FUNCTION_DECL or + OVERLOAD) to the CANDIDATES, returning an updated list of + CANDIDATES. The ARGS are the arguments provided to the call; + if FIRST_ARG is non-null it is the implicit object argument, + otherwise the first element of ARGS is used if needed. The + EXPLICIT_TARGS are explicit template arguments provided. + TEMPLATE_ONLY is true if only template functions should be + considered. CONVERSION_PATH, ACCESS_PATH, and FLAGS are as for + add_function_candidate. */ + +static void +add_candidates (tree fns, tree first_arg, const vec<tree, va_gc> *args, + tree return_type, + tree explicit_targs, bool template_only, + tree conversion_path, tree access_path, + int flags, + struct z_candidate **candidates, + tsubst_flags_t complain) +{ + tree ctype; + const vec<tree, va_gc> *non_static_args; + bool check_list_ctor; + bool check_converting; + unification_kind_t strict; + tree fn; + + if (!fns) + return; + + /* Precalculate special handling of constructors and conversion ops. */ + fn = OVL_CURRENT (fns); + if (DECL_CONV_FN_P (fn)) + { + check_list_ctor = false; + check_converting = !!(flags & LOOKUP_ONLYCONVERTING); + if (flags & LOOKUP_NO_CONVERSION) + /* We're doing return_type(x). */ + strict = DEDUCE_CONV; + else + /* We're doing x.operator return_type(). */ + strict = DEDUCE_EXACT; + /* [over.match.funcs] For conversion functions, the function + is considered to be a member of the class of the implicit + object argument for the purpose of defining the type of + the implicit object parameter. */ + ctype = TYPE_MAIN_VARIANT (TREE_TYPE (first_arg)); + } + else + { + if (DECL_CONSTRUCTOR_P (fn)) + { + check_list_ctor = !!(flags & LOOKUP_LIST_ONLY); + /* For list-initialization we consider explicit constructors + and complain if one is chosen. */ + check_converting + = ((flags & (LOOKUP_ONLYCONVERTING|LOOKUP_LIST_INIT_CTOR)) + == LOOKUP_ONLYCONVERTING); + } + else + { + check_list_ctor = false; + check_converting = false; + } + strict = DEDUCE_CALL; + ctype = conversion_path ? BINFO_TYPE (conversion_path) : NULL_TREE; + } + + if (first_arg) + non_static_args = args; + else + /* Delay creating the implicit this parameter until it is needed. */ + non_static_args = NULL; + + for (; fns; fns = OVL_NEXT (fns)) + { + tree fn_first_arg; + const vec<tree, va_gc> *fn_args; + + fn = OVL_CURRENT (fns); + + if (check_converting && DECL_NONCONVERTING_P (fn)) + continue; + if (check_list_ctor && !is_list_ctor (fn)) + continue; + + /* Figure out which set of arguments to use. */ + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)) + { + /* If this function is a non-static member and we didn't get an + implicit object argument, move it out of args. */ + if (first_arg == NULL_TREE) + { + unsigned int ix; + tree arg; + vec<tree, va_gc> *tempvec; + vec_alloc (tempvec, args->length () - 1); + for (ix = 1; args->iterate (ix, &arg); ++ix) + tempvec->quick_push (arg); + non_static_args = tempvec; + first_arg = (*args)[0]; + } + + fn_first_arg = first_arg; + fn_args = non_static_args; + } + else + { + /* Otherwise, just use the list of arguments provided. */ + fn_first_arg = NULL_TREE; + fn_args = args; + } + + if (TREE_CODE (fn) == TEMPLATE_DECL) + add_template_candidate (candidates, + fn, + ctype, + explicit_targs, + fn_first_arg, + fn_args, + return_type, + access_path, + conversion_path, + flags, + strict, + complain); + else if (!template_only) + add_function_candidate (candidates, + fn, + ctype, + fn_first_arg, + fn_args, + access_path, + conversion_path, + flags, + complain); + } +} + +static tree +build_new_op_1 (location_t loc, enum tree_code code, int flags, tree arg1, + tree arg2, tree arg3, tree *overload, tsubst_flags_t complain) +{ + struct z_candidate *candidates = 0, *cand; + vec<tree, va_gc> *arglist; + tree fnname; + tree args[3]; + tree result = NULL_TREE; + bool result_valid_p = false; + enum tree_code code2 = NOP_EXPR; + enum tree_code code_orig_arg1 = ERROR_MARK; + enum tree_code code_orig_arg2 = ERROR_MARK; + conversion *conv; + void *p; + bool strict_p; + bool any_viable_p; + + if (error_operand_p (arg1) + || error_operand_p (arg2) + || error_operand_p (arg3)) + return error_mark_node; + + if (code == MODIFY_EXPR) + { + code2 = TREE_CODE (arg3); + arg3 = NULL_TREE; + fnname = ansi_assopname (code2); + } + else + fnname = ansi_opname (code); + + arg1 = prep_operand (arg1); + + switch (code) + { + case NEW_EXPR: + case VEC_NEW_EXPR: + case VEC_DELETE_EXPR: + case DELETE_EXPR: + /* Use build_op_new_call and build_op_delete_call instead. */ + gcc_unreachable (); + + case CALL_EXPR: + /* Use build_op_call instead. */ + gcc_unreachable (); + + case TRUTH_ORIF_EXPR: + case TRUTH_ANDIF_EXPR: + case TRUTH_AND_EXPR: + case TRUTH_OR_EXPR: + /* These are saved for the sake of warn_logical_operator. */ + code_orig_arg1 = TREE_CODE (arg1); + code_orig_arg2 = TREE_CODE (arg2); + + default: + break; + } + + arg2 = prep_operand (arg2); + arg3 = prep_operand (arg3); + + if (code == COND_EXPR) + /* Use build_conditional_expr instead. */ + gcc_unreachable (); + else if (! OVERLOAD_TYPE_P (TREE_TYPE (arg1)) + && (! arg2 || ! OVERLOAD_TYPE_P (TREE_TYPE (arg2)))) + goto builtin; + + if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) + arg2 = integer_zero_node; + + vec_alloc (arglist, 3); + arglist->quick_push (arg1); + if (arg2 != NULL_TREE) + arglist->quick_push (arg2); + if (arg3 != NULL_TREE) + arglist->quick_push (arg3); + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + /* Add namespace-scope operators to the list of functions to + consider. */ + add_candidates (lookup_function_nonclass (fnname, arglist, /*block_p=*/true), + NULL_TREE, arglist, NULL_TREE, + NULL_TREE, false, NULL_TREE, NULL_TREE, + flags, &candidates, complain); + + args[0] = arg1; + args[1] = arg2; + args[2] = NULL_TREE; + + /* Add class-member operators to the candidate set. */ + if (CLASS_TYPE_P (TREE_TYPE (arg1))) + { + tree fns; + + fns = lookup_fnfields (TREE_TYPE (arg1), fnname, 1); + if (fns == error_mark_node) + { + result = error_mark_node; + goto user_defined_result_ready; + } + if (fns) + add_candidates (BASELINK_FUNCTIONS (fns), + NULL_TREE, arglist, NULL_TREE, + NULL_TREE, false, + BASELINK_BINFO (fns), + BASELINK_ACCESS_BINFO (fns), + flags, &candidates, complain); + } + /* Per 13.3.1.2/3, 2nd bullet, if no operand has a class type, then + only non-member functions that have type T1 or reference to + cv-qualified-opt T1 for the first argument, if the first argument + has an enumeration type, or T2 or reference to cv-qualified-opt + T2 for the second argument, if the the second argument has an + enumeration type. Filter out those that don't match. */ + else if (! arg2 || ! CLASS_TYPE_P (TREE_TYPE (arg2))) + { + struct z_candidate **candp, **next; + + for (candp = &candidates; *candp; candp = next) + { + tree parmlist, parmtype; + int i, nargs = (arg2 ? 2 : 1); + + cand = *candp; + next = &cand->next; + + parmlist = TYPE_ARG_TYPES (TREE_TYPE (cand->fn)); + + for (i = 0; i < nargs; ++i) + { + parmtype = TREE_VALUE (parmlist); + + if (TREE_CODE (parmtype) == REFERENCE_TYPE) + parmtype = TREE_TYPE (parmtype); + if (TREE_CODE (TREE_TYPE (args[i])) == ENUMERAL_TYPE + && (same_type_ignoring_top_level_qualifiers_p + (TREE_TYPE (args[i]), parmtype))) + break; + + parmlist = TREE_CHAIN (parmlist); + } + + /* No argument has an appropriate type, so remove this + candidate function from the list. */ + if (i == nargs) + { + *candp = cand->next; + next = candp; + } + } + } + + add_builtin_candidates (&candidates, code, code2, fnname, args, + flags, complain); + + switch (code) + { + case COMPOUND_EXPR: + case ADDR_EXPR: + /* For these, the built-in candidates set is empty + [over.match.oper]/3. We don't want non-strict matches + because exact matches are always possible with built-in + operators. The built-in candidate set for COMPONENT_REF + would be empty too, but since there are no such built-in + operators, we accept non-strict matches for them. */ + strict_p = true; + break; + + default: + strict_p = pedantic; + break; + } + + candidates = splice_viable (candidates, strict_p, &any_viable_p); + if (!any_viable_p) + { + switch (code) + { + case POSTINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + /* Don't try anything fancy if we're not allowed to produce + errors. */ + if (!(complain & tf_error)) + return error_mark_node; + + /* Look for an `operator++ (int)'. Pre-1985 C++ didn't + distinguish between prefix and postfix ++ and + operator++() was used for both, so we allow this with + -fpermissive. */ + else + { + const char *msg = (flag_permissive) + ? G_("no %<%D(int)%> declared for postfix %qs," + " trying prefix operator instead") + : G_("no %<%D(int)%> declared for postfix %qs"); + permerror (loc, msg, fnname, operator_name_info[code].name); + } + + if (!flag_permissive) + return error_mark_node; + + if (code == POSTINCREMENT_EXPR) + code = PREINCREMENT_EXPR; + else + code = PREDECREMENT_EXPR; + result = build_new_op_1 (loc, code, flags, arg1, NULL_TREE, + NULL_TREE, overload, complain); + break; + + /* The caller will deal with these. */ + case ADDR_EXPR: + case COMPOUND_EXPR: + case COMPONENT_REF: + result = NULL_TREE; + result_valid_p = true; + break; + + default: + if (complain & tf_error) + { + /* If one of the arguments of the operator represents + an invalid use of member function pointer, try to report + a meaningful error ... */ + if (invalid_nonstatic_memfn_p (arg1, tf_error) + || invalid_nonstatic_memfn_p (arg2, tf_error) + || invalid_nonstatic_memfn_p (arg3, tf_error)) + /* We displayed the error message. */; + else + { + /* ... Otherwise, report the more generic + "no matching operator found" error */ + op_error (loc, code, code2, arg1, arg2, arg3, FALSE); + print_z_candidates (loc, candidates); + } + } + result = error_mark_node; + break; + } + } + else + { + cand = tourney (candidates, complain); + if (cand == 0) + { + if (complain & tf_error) + { + op_error (loc, code, code2, arg1, arg2, arg3, TRUE); + print_z_candidates (loc, candidates); + } + result = error_mark_node; + } + else if (TREE_CODE (cand->fn) == FUNCTION_DECL) + { + if (overload) + *overload = cand->fn; + + if (resolve_args (arglist, complain) == NULL) + result = error_mark_node; + else + result = build_over_call (cand, LOOKUP_NORMAL, complain); + } + else + { + /* Give any warnings we noticed during overload resolution. */ + if (cand->warnings && (complain & tf_warning)) + { + struct candidate_warning *w; + for (w = cand->warnings; w; w = w->next) + joust (cand, w->loser, 1, complain); + } + + /* Check for comparison of different enum types. */ + switch (code) + { + case GT_EXPR: + case LT_EXPR: + case GE_EXPR: + case LE_EXPR: + case EQ_EXPR: + case NE_EXPR: + if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE + && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE + && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) + != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))) + && (complain & tf_warning)) + { + warning (OPT_Wenum_compare, + "comparison between %q#T and %q#T", + TREE_TYPE (arg1), TREE_TYPE (arg2)); + } + break; + default: + break; + } + + /* We need to strip any leading REF_BIND so that bitfields + don't cause errors. This should not remove any important + conversions, because builtins don't apply to class + objects directly. */ + conv = cand->convs[0]; + if (conv->kind == ck_ref_bind) + conv = next_conversion (conv); + arg1 = convert_like (conv, arg1, complain); + + if (arg2) + { + conv = cand->convs[1]; + if (conv->kind == ck_ref_bind) + conv = next_conversion (conv); + else + arg2 = decay_conversion (arg2, complain); + + /* We need to call warn_logical_operator before + converting arg2 to a boolean_type, but after + decaying an enumerator to its value. */ + if (complain & tf_warning) + warn_logical_operator (loc, code, boolean_type_node, + code_orig_arg1, arg1, + code_orig_arg2, arg2); + + arg2 = convert_like (conv, arg2, complain); + } + if (arg3) + { + conv = cand->convs[2]; + if (conv->kind == ck_ref_bind) + conv = next_conversion (conv); + arg3 = convert_like (conv, arg3, complain); + } + + } + } + + user_defined_result_ready: + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + if (result || result_valid_p) + return result; + + builtin: + switch (code) + { + case MODIFY_EXPR: + return cp_build_modify_expr (arg1, code2, arg2, complain); + + case INDIRECT_REF: + return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain); + + case TRUTH_ANDIF_EXPR: + case TRUTH_ORIF_EXPR: + case TRUTH_AND_EXPR: + case TRUTH_OR_EXPR: + warn_logical_operator (loc, code, boolean_type_node, + code_orig_arg1, arg1, code_orig_arg2, arg2); + /* Fall through. */ + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + case TRUNC_DIV_EXPR: + case GT_EXPR: + case LT_EXPR: + case GE_EXPR: + case LE_EXPR: + case EQ_EXPR: + case NE_EXPR: + case MAX_EXPR: + case MIN_EXPR: + case LSHIFT_EXPR: + case RSHIFT_EXPR: + case TRUNC_MOD_EXPR: + case BIT_AND_EXPR: + case BIT_IOR_EXPR: + case BIT_XOR_EXPR: + return cp_build_binary_op (loc, code, arg1, arg2, complain); + + case UNARY_PLUS_EXPR: + case NEGATE_EXPR: + case BIT_NOT_EXPR: + case TRUTH_NOT_EXPR: + case PREINCREMENT_EXPR: + case POSTINCREMENT_EXPR: + case PREDECREMENT_EXPR: + case POSTDECREMENT_EXPR: + case REALPART_EXPR: + case IMAGPART_EXPR: + case ABS_EXPR: + return cp_build_unary_op (code, arg1, candidates != 0, complain); + + case ARRAY_REF: + return cp_build_array_ref (input_location, arg1, arg2, complain); + + case MEMBER_REF: + return build_m_component_ref (cp_build_indirect_ref (arg1, RO_ARROW_STAR, + complain), + arg2, complain); + + /* The caller will deal with these. */ + case ADDR_EXPR: + case COMPONENT_REF: + case COMPOUND_EXPR: + return NULL_TREE; + + default: + gcc_unreachable (); + } + return NULL_TREE; +} + +/* Wrapper for above. */ + +tree +build_new_op (location_t loc, enum tree_code code, int flags, + tree arg1, tree arg2, tree arg3, + tree *overload, tsubst_flags_t complain) +{ + tree ret; + bool subtime = timevar_cond_start (TV_OVERLOAD); + ret = build_new_op_1 (loc, code, flags, arg1, arg2, arg3, + overload, complain); + timevar_cond_stop (TV_OVERLOAD, subtime); + return ret; +} + +/* Returns true iff T, an element of an OVERLOAD chain, is a usual + deallocation function (3.7.4.2 [basic.stc.dynamic.deallocation]). */ + +static bool +non_placement_deallocation_fn_p (tree t) +{ + /* A template instance is never a usual deallocation function, + regardless of its signature. */ + if (TREE_CODE (t) == TEMPLATE_DECL + || primary_template_instantiation_p (t)) + return false; + + /* If a class T has a member deallocation function named operator delete + with exactly one parameter, then that function is a usual + (non-placement) deallocation function. If class T does not declare + such an operator delete but does declare a member deallocation + function named operator delete with exactly two parameters, the second + of which has type std::size_t (18.2), then this function is a usual + deallocation function. */ + t = FUNCTION_ARG_CHAIN (t); + if (t == void_list_node + || (t && same_type_p (TREE_VALUE (t), size_type_node) + && TREE_CHAIN (t) == void_list_node)) + return true; + return false; +} + +/* Build a call to operator delete. This has to be handled very specially, + because the restrictions on what signatures match are different from all + other call instances. For a normal delete, only a delete taking (void *) + or (void *, size_t) is accepted. For a placement delete, only an exact + match with the placement new is accepted. + + CODE is either DELETE_EXPR or VEC_DELETE_EXPR. + ADDR is the pointer to be deleted. + SIZE is the size of the memory block to be deleted. + GLOBAL_P is true if the delete-expression should not consider + class-specific delete operators. + PLACEMENT is the corresponding placement new call, or NULL_TREE. + + If this call to "operator delete" is being generated as part to + deallocate memory allocated via a new-expression (as per [expr.new] + which requires that if the initialization throws an exception then + we call a deallocation function), then ALLOC_FN is the allocation + function. */ + +tree +build_op_delete_call (enum tree_code code, tree addr, tree size, + bool global_p, tree placement, + tree alloc_fn, tsubst_flags_t complain) +{ + tree fn = NULL_TREE; + tree fns, fnname, type, t; + + if (addr == error_mark_node) + return error_mark_node; + + type = strip_array_types (TREE_TYPE (TREE_TYPE (addr))); + + fnname = ansi_opname (code); + + if (CLASS_TYPE_P (type) + && COMPLETE_TYPE_P (complete_type (type)) + && !global_p) + /* In [class.free] + + If the result of the lookup is ambiguous or inaccessible, or if + the lookup selects a placement deallocation function, the + program is ill-formed. + + Therefore, we ask lookup_fnfields to complain about ambiguity. */ + { + fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1); + if (fns == error_mark_node) + return error_mark_node; + } + else + fns = NULL_TREE; + + if (fns == NULL_TREE) + fns = lookup_name_nonclass (fnname); + + /* Strip const and volatile from addr. */ + addr = cp_convert (ptr_type_node, addr, complain); + + if (placement) + { + /* "A declaration of a placement deallocation function matches the + declaration of a placement allocation function if it has the same + number of parameters and, after parameter transformations (8.3.5), + all parameter types except the first are identical." + + So we build up the function type we want and ask instantiate_type + to get it for us. */ + t = FUNCTION_ARG_CHAIN (alloc_fn); + t = tree_cons (NULL_TREE, ptr_type_node, t); + t = build_function_type (void_type_node, t); + + fn = instantiate_type (t, fns, tf_none); + if (fn == error_mark_node) + return NULL_TREE; + + if (BASELINK_P (fn)) + fn = BASELINK_FUNCTIONS (fn); + + /* "If the lookup finds the two-parameter form of a usual deallocation + function (3.7.4.2) and that function, considered as a placement + deallocation function, would have been selected as a match for the + allocation function, the program is ill-formed." */ + if (non_placement_deallocation_fn_p (fn)) + { + /* But if the class has an operator delete (void *), then that is + the usual deallocation function, so we shouldn't complain + about using the operator delete (void *, size_t). */ + for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; + t; t = OVL_NEXT (t)) + { + tree elt = OVL_CURRENT (t); + if (non_placement_deallocation_fn_p (elt) + && FUNCTION_ARG_CHAIN (elt) == void_list_node) + goto ok; + } + if (complain & tf_error) + { + permerror (0, "non-placement deallocation function %q+D", fn); + permerror (input_location, "selected for placement delete"); + } + else + return error_mark_node; + ok:; + } + } + else + /* "Any non-placement deallocation function matches a non-placement + allocation function. If the lookup finds a single matching + deallocation function, that function will be called; otherwise, no + deallocation function will be called." */ + for (t = BASELINK_P (fns) ? BASELINK_FUNCTIONS (fns) : fns; + t; t = OVL_NEXT (t)) + { + tree elt = OVL_CURRENT (t); + if (non_placement_deallocation_fn_p (elt)) + { + fn = elt; + /* "If a class T has a member deallocation function named + operator delete with exactly one parameter, then that + function is a usual (non-placement) deallocation + function. If class T does not declare such an operator + delete but does declare a member deallocation function named + operator delete with exactly two parameters, the second of + which has type std::size_t (18.2), then this function is a + usual deallocation function." + + So (void*) beats (void*, size_t). */ + if (FUNCTION_ARG_CHAIN (fn) == void_list_node) + break; + } + } + + /* If we have a matching function, call it. */ + if (fn) + { + gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); + + /* If the FN is a member function, make sure that it is + accessible. */ + if (BASELINK_P (fns)) + perform_or_defer_access_check (BASELINK_BINFO (fns), fn, fn, + complain); + + /* Core issue 901: It's ok to new a type with deleted delete. */ + if (DECL_DELETED_FN (fn) && alloc_fn) + return NULL_TREE; + + if (placement) + { + /* The placement args might not be suitable for overload + resolution at this point, so build the call directly. */ + int nargs = call_expr_nargs (placement); + tree *argarray = XALLOCAVEC (tree, nargs); + int i; + argarray[0] = addr; + for (i = 1; i < nargs; i++) + argarray[i] = CALL_EXPR_ARG (placement, i); + mark_used (fn); + return build_cxx_call (fn, nargs, argarray, complain); + } + else + { + tree ret; + vec<tree, va_gc> *args = make_tree_vector (); + args->quick_push (addr); + if (FUNCTION_ARG_CHAIN (fn) != void_list_node) + args->quick_push (size); + ret = cp_build_function_call_vec (fn, &args, complain); + release_tree_vector (args); + return ret; + } + } + + /* [expr.new] + + If no unambiguous matching deallocation function can be found, + propagating the exception does not cause the object's memory to + be freed. */ + if (alloc_fn) + { + if ((complain & tf_warning) + && !placement) + warning (0, "no corresponding deallocation function for %qD", + alloc_fn); + return NULL_TREE; + } + + if (complain & tf_error) + error ("no suitable %<operator %s%> for %qT", + operator_name_info[(int)code].name, type); + return error_mark_node; +} + +/* If the current scope isn't allowed to access DECL along + BASETYPE_PATH, give an error. The most derived class in + BASETYPE_PATH is the one used to qualify DECL. DIAG_DECL is + the declaration to use in the error diagnostic. */ + +bool +enforce_access (tree basetype_path, tree decl, tree diag_decl, + tsubst_flags_t complain) +{ + gcc_assert (TREE_CODE (basetype_path) == TREE_BINFO); + + if (!accessible_p (basetype_path, decl, true)) + { + if (complain & tf_error) + { + if (TREE_PRIVATE (decl)) + error ("%q+#D is private", diag_decl); + else if (TREE_PROTECTED (decl)) + error ("%q+#D is protected", diag_decl); + else + error ("%q+#D is inaccessible", diag_decl); + error ("within this context"); + } + return false; + } + + return true; +} + +/* Initialize a temporary of type TYPE with EXPR. The FLAGS are a + bitwise or of LOOKUP_* values. If any errors are warnings are + generated, set *DIAGNOSTIC_FN to "error" or "warning", + respectively. If no diagnostics are generated, set *DIAGNOSTIC_FN + to NULL. */ + +static tree +build_temp (tree expr, tree type, int flags, + diagnostic_t *diagnostic_kind, tsubst_flags_t complain) +{ + int savew, savee; + vec<tree, va_gc> *args; + + savew = warningcount + werrorcount, savee = errorcount; + args = make_tree_vector_single (expr); + expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, + &args, type, flags, complain); + release_tree_vector (args); + if (warningcount + werrorcount > savew) + *diagnostic_kind = DK_WARNING; + else if (errorcount > savee) + *diagnostic_kind = DK_ERROR; + else + *diagnostic_kind = DK_UNSPECIFIED; + return expr; +} + +/* Perform warnings about peculiar, but valid, conversions from/to NULL. + EXPR is implicitly converted to type TOTYPE. + FN and ARGNUM are used for diagnostics. */ + +static void +conversion_null_warnings (tree totype, tree expr, tree fn, int argnum) +{ + /* Issue warnings about peculiar, but valid, uses of NULL. */ + if (expr == null_node && TREE_CODE (totype) != BOOLEAN_TYPE + && ARITHMETIC_TYPE_P (totype)) + { + source_location loc = + expansion_point_location_if_in_system_header (input_location); + + if (fn) + warning_at (loc, OPT_Wconversion_null, + "passing NULL to non-pointer argument %P of %qD", + argnum, fn); + else + warning_at (loc, OPT_Wconversion_null, + "converting to non-pointer type %qT from NULL", totype); + } + + /* Issue warnings if "false" is converted to a NULL pointer */ + else if (TREE_CODE (TREE_TYPE (expr)) == BOOLEAN_TYPE + && TYPE_PTR_P (totype)) + { + if (fn) + warning_at (input_location, OPT_Wconversion_null, + "converting %<false%> to pointer type for argument %P " + "of %qD", argnum, fn); + else + warning_at (input_location, OPT_Wconversion_null, + "converting %<false%> to pointer type %qT", totype); + } +} + +/* Perform the conversions in CONVS on the expression EXPR. FN and + ARGNUM are used for diagnostics. ARGNUM is zero based, -1 + indicates the `this' argument of a method. INNER is nonzero when + being called to continue a conversion chain. It is negative when a + reference binding will be applied, positive otherwise. If + ISSUE_CONVERSION_WARNINGS is true, warnings about suspicious + conversions will be emitted if appropriate. If C_CAST_P is true, + this conversion is coming from a C-style cast; in that case, + conversions to inaccessible bases are permitted. */ + +static tree +convert_like_real (conversion *convs, tree expr, tree fn, int argnum, + int inner, bool issue_conversion_warnings, + bool c_cast_p, tsubst_flags_t complain) +{ + tree totype = convs->type; + diagnostic_t diag_kind; + int flags; + location_t loc = EXPR_LOC_OR_LOC (expr, input_location); + + if (convs->bad_p && !(complain & tf_error)) + return error_mark_node; + + if (convs->bad_p + && convs->kind != ck_user + && convs->kind != ck_list + && convs->kind != ck_ambig + && (convs->kind != ck_ref_bind + || (convs->user_conv_p && next_conversion (convs)->bad_p)) + && (convs->kind != ck_rvalue + || SCALAR_TYPE_P (totype)) + && convs->kind != ck_base) + { + bool complained = false; + conversion *t = convs; + + /* Give a helpful error if this is bad because of excess braces. */ + if (BRACE_ENCLOSED_INITIALIZER_P (expr) + && SCALAR_TYPE_P (totype) + && CONSTRUCTOR_NELTS (expr) > 0 + && BRACE_ENCLOSED_INITIALIZER_P (CONSTRUCTOR_ELT (expr, 0)->value)) + { + complained = permerror (loc, "too many braces around initializer " + "for %qT", totype); + while (BRACE_ENCLOSED_INITIALIZER_P (expr) + && CONSTRUCTOR_NELTS (expr) == 1) + expr = CONSTRUCTOR_ELT (expr, 0)->value; + } + + for (; t ; t = next_conversion (t)) + { + if (t->kind == ck_user && t->cand->reason) + { + permerror (loc, "invalid user-defined conversion " + "from %qT to %qT", TREE_TYPE (expr), totype); + print_z_candidate (loc, "candidate is:", t->cand); + expr = convert_like_real (t, expr, fn, argnum, 1, + /*issue_conversion_warnings=*/false, + /*c_cast_p=*/false, + complain); + if (convs->kind == ck_ref_bind) + return convert_to_reference (totype, expr, CONV_IMPLICIT, + LOOKUP_NORMAL, NULL_TREE, + complain); + else + return cp_convert (totype, expr, complain); + } + else if (t->kind == ck_user || !t->bad_p) + { + expr = convert_like_real (t, expr, fn, argnum, 1, + /*issue_conversion_warnings=*/false, + /*c_cast_p=*/false, + complain); + break; + } + else if (t->kind == ck_ambig) + return convert_like_real (t, expr, fn, argnum, 1, + /*issue_conversion_warnings=*/false, + /*c_cast_p=*/false, + complain); + else if (t->kind == ck_identity) + break; + } + if (!complained) + complained = permerror (loc, "invalid conversion from %qT to %qT", + TREE_TYPE (expr), totype); + if (complained && fn) + inform (DECL_SOURCE_LOCATION (fn), + "initializing argument %P of %qD", argnum, fn); + + return cp_convert (totype, expr, complain); + } + + if (issue_conversion_warnings && (complain & tf_warning)) + conversion_null_warnings (totype, expr, fn, argnum); + + switch (convs->kind) + { + case ck_user: + { + struct z_candidate *cand = convs->cand; + tree convfn = cand->fn; + unsigned i; + + /* When converting from an init list we consider explicit + constructors, but actually trying to call one is an error. */ + if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn) + /* Unless this is for direct-list-initialization. */ + && !(BRACE_ENCLOSED_INITIALIZER_P (expr) + && CONSTRUCTOR_IS_DIRECT_INIT (expr))) + { + if (!(complain & tf_error)) + return error_mark_node; + error ("converting to %qT from initializer list would use " + "explicit constructor %qD", totype, convfn); + } + + /* If we're initializing from {}, it's value-initialization. */ + if (BRACE_ENCLOSED_INITIALIZER_P (expr) + && CONSTRUCTOR_NELTS (expr) == 0 + && TYPE_HAS_DEFAULT_CONSTRUCTOR (totype)) + { + bool direct = CONSTRUCTOR_IS_DIRECT_INIT (expr); + expr = build_value_init (totype, complain); + expr = get_target_expr_sfinae (expr, complain); + if (expr != error_mark_node) + { + TARGET_EXPR_LIST_INIT_P (expr) = true; + TARGET_EXPR_DIRECT_INIT_P (expr) = direct; + } + return expr; + } + + expr = mark_rvalue_use (expr); + + /* Set user_conv_p on the argument conversions, so rvalue/base + handling knows not to allow any more UDCs. */ + for (i = 0; i < cand->num_convs; ++i) + cand->convs[i]->user_conv_p = true; + + expr = build_over_call (cand, LOOKUP_NORMAL, complain); + + /* If this is a constructor or a function returning an aggr type, + we need to build up a TARGET_EXPR. */ + if (DECL_CONSTRUCTOR_P (convfn)) + { + expr = build_cplus_new (totype, expr, complain); + + /* Remember that this was list-initialization. */ + if (convs->check_narrowing && expr != error_mark_node) + TARGET_EXPR_LIST_INIT_P (expr) = true; + } + + return expr; + } + case ck_identity: + expr = mark_rvalue_use (expr); + if (BRACE_ENCLOSED_INITIALIZER_P (expr)) + { + int nelts = CONSTRUCTOR_NELTS (expr); + if (nelts == 0) + expr = build_value_init (totype, complain); + else if (nelts == 1) + expr = CONSTRUCTOR_ELT (expr, 0)->value; + else + gcc_unreachable (); + } + + if (type_unknown_p (expr)) + expr = instantiate_type (totype, expr, complain); + /* Convert a constant to its underlying value, unless we are + about to bind it to a reference, in which case we need to + leave it as an lvalue. */ + if (inner >= 0) + { + expr = decl_constant_value_safe (expr); + if (expr == null_node && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (totype)) + /* If __null has been converted to an integer type, we do not + want to warn about uses of EXPR as an integer, rather than + as a pointer. */ + expr = build_int_cst (totype, 0); + } + return expr; + case ck_ambig: + /* We leave bad_p off ck_ambig because overload resolution considers + it valid, it just fails when we try to perform it. So we need to + check complain here, too. */ + if (complain & tf_error) + { + /* Call build_user_type_conversion again for the error. */ + build_user_type_conversion (totype, convs->u.expr, LOOKUP_NORMAL, + complain); + if (fn) + inform (input_location, "initializing argument %P of %q+D", + argnum, fn); + } + return error_mark_node; + + case ck_list: + { + /* Conversion to std::initializer_list<T>. */ + tree elttype = TREE_VEC_ELT (CLASSTYPE_TI_ARGS (totype), 0); + tree new_ctor = build_constructor (init_list_type_node, NULL); + unsigned len = CONSTRUCTOR_NELTS (expr); + tree array, val, field; + vec<constructor_elt, va_gc> *vec = NULL; + unsigned ix; + + /* Convert all the elements. */ + FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr), ix, val) + { + tree sub = convert_like_real (convs->u.list[ix], val, fn, argnum, + 1, false, false, complain); + if (sub == error_mark_node) + return sub; + if (!BRACE_ENCLOSED_INITIALIZER_P (val)) + check_narrowing (TREE_TYPE (sub), val); + CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_ctor), NULL_TREE, sub); + if (!TREE_CONSTANT (sub)) + TREE_CONSTANT (new_ctor) = false; + } + /* Build up the array. */ + elttype = cp_build_qualified_type + (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST); + array = build_array_of_n_type (elttype, len); + array = finish_compound_literal (array, new_ctor, complain); + /* Take the address explicitly rather than via decay_conversion + to avoid the error about taking the address of a temporary. */ + array = cp_build_addr_expr (array, complain); + array = cp_convert (build_pointer_type (elttype), array, complain); + if (array == error_mark_node) + return error_mark_node; + + /* Build up the initializer_list object. */ + totype = complete_type (totype); + field = next_initializable_field (TYPE_FIELDS (totype)); + CONSTRUCTOR_APPEND_ELT (vec, field, array); + field = next_initializable_field (DECL_CHAIN (field)); + CONSTRUCTOR_APPEND_ELT (vec, field, size_int (len)); + new_ctor = build_constructor (totype, vec); + return get_target_expr_sfinae (new_ctor, complain); + } + + case ck_aggr: + if (TREE_CODE (totype) == COMPLEX_TYPE) + { + tree real = CONSTRUCTOR_ELT (expr, 0)->value; + tree imag = CONSTRUCTOR_ELT (expr, 1)->value; + real = perform_implicit_conversion (TREE_TYPE (totype), + real, complain); + imag = perform_implicit_conversion (TREE_TYPE (totype), + imag, complain); + expr = build2 (COMPLEX_EXPR, totype, real, imag); + return fold_if_not_in_template (expr); + } + expr = reshape_init (totype, expr, complain); + expr = get_target_expr_sfinae (digest_init (totype, expr, complain), + complain); + if (expr != error_mark_node) + TARGET_EXPR_LIST_INIT_P (expr) = true; + return expr; + + default: + break; + }; + + expr = convert_like_real (next_conversion (convs), expr, fn, argnum, + convs->kind == ck_ref_bind ? -1 : 1, + convs->kind == ck_ref_bind ? issue_conversion_warnings : false, + c_cast_p, + complain); + if (expr == error_mark_node) + return error_mark_node; + + switch (convs->kind) + { + case ck_rvalue: + expr = decay_conversion (expr, complain); + if (expr == error_mark_node) + return error_mark_node; + + if (! MAYBE_CLASS_TYPE_P (totype)) + return expr; + /* Else fall through. */ + case ck_base: + if (convs->kind == ck_base && !convs->need_temporary_p) + { + /* We are going to bind a reference directly to a base-class + subobject of EXPR. */ + /* Build an expression for `*((base*) &expr)'. */ + expr = cp_build_addr_expr (expr, complain); + expr = convert_to_base (expr, build_pointer_type (totype), + !c_cast_p, /*nonnull=*/true, complain); + expr = cp_build_indirect_ref (expr, RO_IMPLICIT_CONVERSION, complain); + return expr; + } + + /* Copy-initialization where the cv-unqualified version of the source + type is the same class as, or a derived class of, the class of the + destination [is treated as direct-initialization]. [dcl.init] */ + flags = LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING; + if (convs->user_conv_p) + /* This conversion is being done in the context of a user-defined + conversion (i.e. the second step of copy-initialization), so + don't allow any more. */ + flags |= LOOKUP_NO_CONVERSION; + if (convs->rvaluedness_matches_p) + flags |= LOOKUP_PREFER_RVALUE; + if (TREE_CODE (expr) == TARGET_EXPR + && TARGET_EXPR_LIST_INIT_P (expr)) + /* Copy-list-initialization doesn't actually involve a copy. */ + return expr; + expr = build_temp (expr, totype, flags, &diag_kind, complain); + if (diag_kind && fn && complain) + emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (fn), 0, + " initializing argument %P of %qD", argnum, fn); + return build_cplus_new (totype, expr, complain); + + case ck_ref_bind: + { + tree ref_type = totype; + + if (convs->bad_p && !next_conversion (convs)->bad_p) + { + gcc_assert (TYPE_REF_IS_RVALUE (ref_type) + && (real_lvalue_p (expr) + || next_conversion(convs)->kind == ck_rvalue)); + + error_at (loc, "cannot bind %qT lvalue to %qT", + TREE_TYPE (expr), totype); + if (fn) + inform (input_location, + "initializing argument %P of %q+D", argnum, fn); + return error_mark_node; + } + + /* If necessary, create a temporary. + + VA_ARG_EXPR and CONSTRUCTOR expressions are special cases + that need temporaries, even when their types are reference + compatible with the type of reference being bound, so the + upcoming call to cp_build_addr_expr doesn't fail. */ + if (convs->need_temporary_p + || TREE_CODE (expr) == CONSTRUCTOR + || TREE_CODE (expr) == VA_ARG_EXPR) + { + /* Otherwise, a temporary of type "cv1 T1" is created and + initialized from the initializer expression using the rules + for a non-reference copy-initialization (8.5). */ + + tree type = TREE_TYPE (ref_type); + cp_lvalue_kind lvalue = real_lvalue_p (expr); + + gcc_assert (same_type_ignoring_top_level_qualifiers_p + (type, next_conversion (convs)->type)); + if (!CP_TYPE_CONST_NON_VOLATILE_P (type) + && !TYPE_REF_IS_RVALUE (ref_type)) + { + /* If the reference is volatile or non-const, we + cannot create a temporary. */ + if (lvalue & clk_bitfield) + error_at (loc, "cannot bind bitfield %qE to %qT", + expr, ref_type); + else if (lvalue & clk_packed) + error_at (loc, "cannot bind packed field %qE to %qT", + expr, ref_type); + else + error_at (loc, "cannot bind rvalue %qE to %qT", + expr, ref_type); + return error_mark_node; + } + /* If the source is a packed field, and we must use a copy + constructor, then building the target expr will require + binding the field to the reference parameter to the + copy constructor, and we'll end up with an infinite + loop. If we can use a bitwise copy, then we'll be + OK. */ + if ((lvalue & clk_packed) + && CLASS_TYPE_P (type) + && type_has_nontrivial_copy_init (type)) + { + error_at (loc, "cannot bind packed field %qE to %qT", + expr, ref_type); + return error_mark_node; + } + if (lvalue & clk_bitfield) + { + expr = convert_bitfield_to_declared_type (expr); + expr = fold_convert (type, expr); + } + expr = build_target_expr_with_type (expr, type, complain); + } + + /* Take the address of the thing to which we will bind the + reference. */ + expr = cp_build_addr_expr (expr, complain); + if (expr == error_mark_node) + return error_mark_node; + + /* Convert it to a pointer to the type referred to by the + reference. This will adjust the pointer if a derived to + base conversion is being performed. */ + expr = cp_convert (build_pointer_type (TREE_TYPE (ref_type)), + expr, complain); + /* Convert the pointer to the desired reference type. */ + return build_nop (ref_type, expr); + } + + case ck_lvalue: + return decay_conversion (expr, complain); + + case ck_qual: + /* Warn about deprecated conversion if appropriate. */ + string_conv_p (totype, expr, 1); + break; + + case ck_ptr: + if (convs->base_p) + expr = convert_to_base (expr, totype, !c_cast_p, + /*nonnull=*/false, complain); + return build_nop (totype, expr); + + case ck_pmem: + return convert_ptrmem (totype, expr, /*allow_inverse_p=*/false, + c_cast_p, complain); + + default: + break; + } + + if (convs->check_narrowing) + check_narrowing (totype, expr); + + if (issue_conversion_warnings) + expr = cp_convert_and_check (totype, expr, complain); + else + expr = cp_convert (totype, expr, complain); + + return expr; +} + +/* ARG is being passed to a varargs function. Perform any conversions + required. Return the converted value. */ + +tree +convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) +{ + tree arg_type; + location_t loc = EXPR_LOC_OR_LOC (arg, input_location); + + /* [expr.call] + + The lvalue-to-rvalue, array-to-pointer, and function-to-pointer + standard conversions are performed. */ + arg = decay_conversion (arg, complain); + arg_type = TREE_TYPE (arg); + /* [expr.call] + + If the argument has integral or enumeration type that is subject + to the integral promotions (_conv.prom_), or a floating point + type that is subject to the floating point promotion + (_conv.fpprom_), the value of the argument is converted to the + promoted type before the call. */ + if (TREE_CODE (arg_type) == REAL_TYPE + && (TYPE_PRECISION (arg_type) + < TYPE_PRECISION (double_type_node)) + && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (arg_type))) + { + if ((complain & tf_warning) + && warn_double_promotion && !c_inhibit_evaluation_warnings) + warning_at (loc, OPT_Wdouble_promotion, + "implicit conversion from %qT to %qT when passing " + "argument to function", + arg_type, double_type_node); + arg = convert_to_real (double_type_node, arg); + } + else if (NULLPTR_TYPE_P (arg_type)) + arg = null_pointer_node; + else if (INTEGRAL_OR_ENUMERATION_TYPE_P (arg_type)) + { + if (SCOPED_ENUM_P (arg_type) && !abi_version_at_least (6)) + { + if (complain & tf_warning) + warning_at (loc, OPT_Wabi, "scoped enum %qT will not promote to an " + "integral type in a future version of GCC", arg_type); + arg = cp_convert (ENUM_UNDERLYING_TYPE (arg_type), arg, complain); + } + arg = cp_perform_integral_promotions (arg, complain); + } + + arg = require_complete_type_sfinae (arg, complain); + arg_type = TREE_TYPE (arg); + + if (arg != error_mark_node + /* In a template (or ill-formed code), we can have an incomplete type + even after require_complete_type_sfinae, in which case we don't know + whether it has trivial copy or not. */ + && COMPLETE_TYPE_P (arg_type)) + { + /* Build up a real lvalue-to-rvalue conversion in case the + copy constructor is trivial but not callable. */ + if (!cp_unevaluated_operand && CLASS_TYPE_P (arg_type)) + force_rvalue (arg, complain); + + /* [expr.call] 5.2.2/7: + Passing a potentially-evaluated argument of class type (Clause 9) + with a non-trivial copy constructor or a non-trivial destructor + with no corresponding parameter is conditionally-supported, with + implementation-defined semantics. + + We used to just warn here and do a bitwise copy, but now + cp_expr_size will abort if we try to do that. + + If the call appears in the context of a sizeof expression, + it is not potentially-evaluated. */ + if (cp_unevaluated_operand == 0 + && (type_has_nontrivial_copy_init (arg_type) + || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (arg_type))) + { + if (complain & tf_error) + error_at (loc, "cannot pass objects of non-trivially-copyable " + "type %q#T through %<...%>", arg_type); + return error_mark_node; + } + } + + return arg; +} + +/* va_arg (EXPR, TYPE) is a builtin. Make sure it is not abused. */ + +tree +build_x_va_arg (source_location loc, tree expr, tree type) +{ + if (processing_template_decl) + return build_min (VA_ARG_EXPR, type, expr); + + type = complete_type_or_else (type, NULL_TREE); + + if (expr == error_mark_node || !type) + return error_mark_node; + + expr = mark_lvalue_use (expr); + + if (type_has_nontrivial_copy_init (type) + || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) + || TREE_CODE (type) == REFERENCE_TYPE) + { + /* Remove reference types so we don't ICE later on. */ + tree type1 = non_reference (type); + /* conditionally-supported behavior [expr.call] 5.2.2/7. */ + error ("cannot receive objects of non-trivially-copyable type %q#T " + "through %<...%>; ", type); + expr = convert (build_pointer_type (type1), null_node); + expr = cp_build_indirect_ref (expr, RO_NULL, tf_warning_or_error); + return expr; + } + + return build_va_arg (loc, expr, type); +} + +/* TYPE has been given to va_arg. Apply the default conversions which + would have happened when passed via ellipsis. Return the promoted + type, or the passed type if there is no change. */ + +tree +cxx_type_promotes_to (tree type) +{ + tree promote; + + /* Perform the array-to-pointer and function-to-pointer + conversions. */ + type = type_decays_to (type); + + promote = type_promotes_to (type); + if (same_type_p (type, promote)) + promote = type; + + return promote; +} + +/* ARG is a default argument expression being passed to a parameter of + the indicated TYPE, which is a parameter to FN. PARMNUM is the + zero-based argument number. Do any required conversions. Return + the converted value. */ + +static GTY(()) vec<tree, va_gc> *default_arg_context; +void +push_defarg_context (tree fn) +{ vec_safe_push (default_arg_context, fn); } + +void +pop_defarg_context (void) +{ default_arg_context->pop (); } + +tree +convert_default_arg (tree type, tree arg, tree fn, int parmnum, + tsubst_flags_t complain) +{ + int i; + tree t; + + /* See through clones. */ + fn = DECL_ORIGIN (fn); + + /* Detect recursion. */ + FOR_EACH_VEC_SAFE_ELT (default_arg_context, i, t) + if (t == fn) + { + if (complain & tf_error) + error ("recursive evaluation of default argument for %q#D", fn); + return error_mark_node; + } + + /* If the ARG is an unparsed default argument expression, the + conversion cannot be performed. */ + if (TREE_CODE (arg) == DEFAULT_ARG) + { + if (complain & tf_error) + error ("call to %qD uses the default argument for parameter %P, which " + "is not yet defined", fn, parmnum); + return error_mark_node; + } + + push_defarg_context (fn); + + if (fn && DECL_TEMPLATE_INFO (fn)) + arg = tsubst_default_argument (fn, type, arg, complain); + + /* Due to: + + [dcl.fct.default] + + The names in the expression are bound, and the semantic + constraints are checked, at the point where the default + expressions appears. + + we must not perform access checks here. */ + push_deferring_access_checks (dk_no_check); + /* We must make a copy of ARG, in case subsequent processing + alters any part of it. */ + arg = break_out_target_exprs (arg); + arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT, + ICR_DEFAULT_ARGUMENT, fn, parmnum, + complain); + arg = convert_for_arg_passing (type, arg, complain); + pop_deferring_access_checks(); + + pop_defarg_context (); + + return arg; +} + +/* Returns the type which will really be used for passing an argument of + type TYPE. */ + +tree +type_passed_as (tree type) +{ + /* Pass classes with copy ctors by invisible reference. */ + if (TREE_ADDRESSABLE (type)) + { + type = build_reference_type (type); + /* There are no other pointers to this temporary. */ + type = cp_build_qualified_type (type, TYPE_QUAL_RESTRICT); + } + else if (targetm.calls.promote_prototypes (type) + && INTEGRAL_TYPE_P (type) + && COMPLETE_TYPE_P (type) + && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), + TYPE_SIZE (integer_type_node))) + type = integer_type_node; + + return type; +} + +/* Actually perform the appropriate conversion. */ + +tree +convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain) +{ + tree bitfield_type; + + /* If VAL is a bitfield, then -- since it has already been converted + to TYPE -- it cannot have a precision greater than TYPE. + + If it has a smaller precision, we must widen it here. For + example, passing "int f:3;" to a function expecting an "int" will + not result in any conversion before this point. + + If the precision is the same we must not risk widening. For + example, the COMPONENT_REF for a 32-bit "long long" bitfield will + often have type "int", even though the C++ type for the field is + "long long". If the value is being passed to a function + expecting an "int", then no conversions will be required. But, + if we call convert_bitfield_to_declared_type, the bitfield will + be converted to "long long". */ + bitfield_type = is_bitfield_expr_with_lowered_type (val); + if (bitfield_type + && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)) + val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val); + + if (val == error_mark_node) + ; + /* Pass classes with copy ctors by invisible reference. */ + else if (TREE_ADDRESSABLE (type)) + val = build1 (ADDR_EXPR, build_reference_type (type), val); + else if (targetm.calls.promote_prototypes (type) + && INTEGRAL_TYPE_P (type) + && COMPLETE_TYPE_P (type) + && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), + TYPE_SIZE (integer_type_node))) + val = cp_perform_integral_promotions (val, complain); + if ((complain & tf_warning) + && warn_suggest_attribute_format) + { + tree rhstype = TREE_TYPE (val); + const enum tree_code coder = TREE_CODE (rhstype); + const enum tree_code codel = TREE_CODE (type); + if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) + && coder == codel + && check_missing_format_attribute (type, rhstype)) + warning (OPT_Wsuggest_attribute_format, + "argument of function call might be a candidate for a format attribute"); + } + return val; +} + +/* Returns true iff FN is a function with magic varargs, i.e. ones for + which no conversions at all should be done. This is true for some + builtins which don't act like normal functions. */ + +bool +magic_varargs_p (tree fn) +{ + if (flag_cilkplus && is_cilkplus_reduce_builtin (fn) != BUILT_IN_NONE) + return true; + + if (DECL_BUILT_IN (fn)) + switch (DECL_FUNCTION_CODE (fn)) + { + case BUILT_IN_CLASSIFY_TYPE: + case BUILT_IN_CONSTANT_P: + case BUILT_IN_NEXT_ARG: + case BUILT_IN_VA_START: + return true; + + default:; + return lookup_attribute ("type generic", + TYPE_ATTRIBUTES (TREE_TYPE (fn))) != 0; + } + + return false; +} + +/* Returns the decl of the dispatcher function if FN is a function version. */ + +tree +get_function_version_dispatcher (tree fn) +{ + tree dispatcher_decl = NULL; + + gcc_assert (TREE_CODE (fn) == FUNCTION_DECL + && DECL_FUNCTION_VERSIONED (fn)); + + gcc_assert (targetm.get_function_versions_dispatcher); + dispatcher_decl = targetm.get_function_versions_dispatcher (fn); + + if (dispatcher_decl == NULL) + { + error_at (input_location, "use of multiversioned function " + "without a default"); + return NULL; + } + + retrofit_lang_decl (dispatcher_decl); + gcc_assert (dispatcher_decl != NULL); + return dispatcher_decl; +} + +/* fn is a function version dispatcher that is marked used. Mark all the + semantically identical function versions it will dispatch as used. */ + +void +mark_versions_used (tree fn) +{ + struct cgraph_node *node; + struct cgraph_function_version_info *node_v; + struct cgraph_function_version_info *it_v; + + gcc_assert (TREE_CODE (fn) == FUNCTION_DECL); + + node = cgraph_get_node (fn); + if (node == NULL) + return; + + gcc_assert (node->dispatcher_function); + + node_v = get_cgraph_node_version (node); + if (node_v == NULL) + return; + + /* All semantically identical versions are chained. Traverse and mark each + one of them as used. */ + it_v = node_v->next; + while (it_v != NULL) + { + mark_used (it_v->this_node->decl); + it_v = it_v->next; + } +} + +/* Subroutine of the various build_*_call functions. Overload resolution + has chosen a winning candidate CAND; build up a CALL_EXPR accordingly. + ARGS is a TREE_LIST of the unconverted arguments to the call. FLAGS is a + bitmask of various LOOKUP_* flags which apply to the call itself. */ + +static tree +build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) +{ + tree fn = cand->fn; + const vec<tree, va_gc> *args = cand->args; + tree first_arg = cand->first_arg; + conversion **convs = cand->convs; + conversion *conv; + tree parm = TYPE_ARG_TYPES (TREE_TYPE (fn)); + int parmlen; + tree val; + int i = 0; + int j = 0; + unsigned int arg_index = 0; + int is_method = 0; + int nargs; + tree *argarray; + bool already_used = false; + + /* In a template, there is no need to perform all of the work that + is normally done. We are only interested in the type of the call + expression, i.e., the return type of the function. Any semantic + errors will be deferred until the template is instantiated. */ + if (processing_template_decl) + { + tree expr, addr; + tree return_type; + const tree *argarray; + unsigned int nargs; + + return_type = TREE_TYPE (TREE_TYPE (fn)); + nargs = vec_safe_length (args); + if (first_arg == NULL_TREE) + argarray = args->address (); + else + { + tree *alcarray; + unsigned int ix; + tree arg; + + ++nargs; + alcarray = XALLOCAVEC (tree, nargs); + alcarray[0] = first_arg; + FOR_EACH_VEC_SAFE_ELT (args, ix, arg) + alcarray[ix + 1] = arg; + argarray = alcarray; + } + + addr = build_addr_func (fn, complain); + if (addr == error_mark_node) + return error_mark_node; + expr = build_call_array_loc (input_location, return_type, + addr, nargs, argarray); + if (TREE_THIS_VOLATILE (fn) && cfun) + current_function_returns_abnormally = 1; + return convert_from_reference (expr); + } + + /* Give any warnings we noticed during overload resolution. */ + if (cand->warnings && (complain & tf_warning)) + { + struct candidate_warning *w; + for (w = cand->warnings; w; w = w->next) + joust (cand, w->loser, 1, complain); + } + + /* Make =delete work with SFINAE. */ + if (DECL_DELETED_FN (fn) && !(complain & tf_error)) + return error_mark_node; + + if (DECL_FUNCTION_MEMBER_P (fn)) + { + tree access_fn; + /* If FN is a template function, two cases must be considered. + For example: + + struct A { + protected: + template <class T> void f(); + }; + template <class T> struct B { + protected: + void g(); + }; + struct C : A, B<int> { + using A::f; // #1 + using B<int>::g; // #2 + }; + + In case #1 where `A::f' is a member template, DECL_ACCESS is + recorded in the primary template but not in its specialization. + We check access of FN using its primary template. + + In case #2, where `B<int>::g' has a DECL_TEMPLATE_INFO simply + because it is a member of class template B, DECL_ACCESS is + recorded in the specialization `B<int>::g'. We cannot use its + primary template because `B<T>::g' and `B<int>::g' may have + different access. */ + if (DECL_TEMPLATE_INFO (fn) + && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (fn))) + access_fn = DECL_TI_TEMPLATE (fn); + else + access_fn = fn; + if (!perform_or_defer_access_check (cand->access_path, access_fn, + fn, complain)) + return error_mark_node; + } + + /* If we're checking for implicit delete, don't bother with argument + conversions. */ + if (flags & LOOKUP_SPECULATIVE) + { + if (DECL_DELETED_FN (fn)) + { + if (complain & tf_error) + mark_used (fn); + return error_mark_node; + } + if (cand->viable == 1) + return fn; + else if (!(complain & tf_error)) + /* Reject bad conversions now. */ + return error_mark_node; + /* else continue to get conversion error. */ + } + + /* N3276 magic doesn't apply to nested calls. */ + int decltype_flag = (complain & tf_decltype); + complain &= ~tf_decltype; + + /* Find maximum size of vector to hold converted arguments. */ + parmlen = list_length (parm); + nargs = vec_safe_length (args) + (first_arg != NULL_TREE ? 1 : 0); + if (parmlen > nargs) + nargs = parmlen; + argarray = XALLOCAVEC (tree, nargs); + + /* The implicit parameters to a constructor are not considered by overload + resolution, and must be of the proper type. */ + if (DECL_CONSTRUCTOR_P (fn)) + { + tree object_arg; + if (first_arg != NULL_TREE) + { + object_arg = first_arg; + first_arg = NULL_TREE; + } + else + { + object_arg = (*args)[arg_index]; + ++arg_index; + } + argarray[j++] = build_this (object_arg); + parm = TREE_CHAIN (parm); + /* We should never try to call the abstract constructor. */ + gcc_assert (!DECL_HAS_IN_CHARGE_PARM_P (fn)); + + if (DECL_HAS_VTT_PARM_P (fn)) + { + argarray[j++] = (*args)[arg_index]; + ++arg_index; + parm = TREE_CHAIN (parm); + } + } + /* Bypass access control for 'this' parameter. */ + else if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE) + { + tree parmtype = TREE_VALUE (parm); + tree arg = build_this (first_arg != NULL_TREE + ? first_arg + : (*args)[arg_index]); + tree argtype = TREE_TYPE (arg); + tree converted_arg; + tree base_binfo; + + if (convs[i]->bad_p) + { + if (complain & tf_error) + permerror (input_location, "passing %qT as %<this%> argument of %q#D discards qualifiers", + TREE_TYPE (argtype), fn); + else + return error_mark_node; + } + + /* See if the function member or the whole class type is declared + final and the call can be devirtualized. */ + if (DECL_FINAL_P (fn) + || CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (TREE_TYPE (fn)))) + flags |= LOOKUP_NONVIRTUAL; + + /* [class.mfct.nonstatic]: If a nonstatic member function of a class + X is called for an object that is not of type X, or of a type + derived from X, the behavior is undefined. + + So we can assume that anything passed as 'this' is non-null, and + optimize accordingly. */ + gcc_assert (TYPE_PTR_P (parmtype)); + /* Convert to the base in which the function was declared. */ + gcc_assert (cand->conversion_path != NULL_TREE); + converted_arg = build_base_path (PLUS_EXPR, + arg, + cand->conversion_path, + 1, complain); + /* Check that the base class is accessible. */ + if (!accessible_base_p (TREE_TYPE (argtype), + BINFO_TYPE (cand->conversion_path), true)) + { + if (complain & tf_error) + error ("%qT is not an accessible base of %qT", + BINFO_TYPE (cand->conversion_path), + TREE_TYPE (argtype)); + else + return error_mark_node; + } + /* If fn was found by a using declaration, the conversion path + will be to the derived class, not the base declaring fn. We + must convert from derived to base. */ + base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)), + TREE_TYPE (parmtype), ba_unique, + NULL, complain); + converted_arg = build_base_path (PLUS_EXPR, converted_arg, + base_binfo, 1, complain); + + argarray[j++] = converted_arg; + parm = TREE_CHAIN (parm); + if (first_arg != NULL_TREE) + first_arg = NULL_TREE; + else + ++arg_index; + ++i; + is_method = 1; + } + + gcc_assert (first_arg == NULL_TREE); + for (; arg_index < vec_safe_length (args) && parm; + parm = TREE_CHAIN (parm), ++arg_index, ++i) + { + tree type = TREE_VALUE (parm); + tree arg = (*args)[arg_index]; + bool conversion_warning = true; + + conv = convs[i]; + + /* If the argument is NULL and used to (implicitly) instantiate a + template function (and bind one of the template arguments to + the type of 'long int'), we don't want to warn about passing NULL + to non-pointer argument. + For example, if we have this template function: + + template<typename T> void func(T x) {} + + we want to warn (when -Wconversion is enabled) in this case: + + void foo() { + func<int>(NULL); + } + + but not in this case: + + void foo() { + func(NULL); + } + */ + if (arg == null_node + && DECL_TEMPLATE_INFO (fn) + && cand->template_decl + && !(flags & LOOKUP_EXPLICIT_TMPL_ARGS)) + conversion_warning = false; + + /* Warn about initializer_list deduction that isn't currently in the + working draft. */ + if (cxx_dialect > cxx98 + && flag_deduce_init_list + && cand->template_decl + && is_std_init_list (non_reference (type)) + && BRACE_ENCLOSED_INITIALIZER_P (arg)) + { + tree tmpl = TI_TEMPLATE (cand->template_decl); + tree realparm = chain_index (j, DECL_ARGUMENTS (cand->fn)); + tree patparm = get_pattern_parm (realparm, tmpl); + tree pattype = TREE_TYPE (patparm); + if (PACK_EXPANSION_P (pattype)) + pattype = PACK_EXPANSION_PATTERN (pattype); + pattype = non_reference (pattype); + + if (TREE_CODE (pattype) == TEMPLATE_TYPE_PARM + && (cand->explicit_targs == NULL_TREE + || (TREE_VEC_LENGTH (cand->explicit_targs) + <= TEMPLATE_TYPE_IDX (pattype)))) + { + pedwarn (input_location, 0, "deducing %qT as %qT", + non_reference (TREE_TYPE (patparm)), + non_reference (type)); + pedwarn (input_location, 0, " in call to %q+D", cand->fn); + pedwarn (input_location, 0, + " (you can disable this with -fno-deduce-init-list)"); + } + } + val = convert_like_with_context (conv, arg, fn, i - is_method, + conversion_warning + ? complain + : complain & (~tf_warning)); + + val = convert_for_arg_passing (type, val, complain); + + if (val == error_mark_node) + return error_mark_node; + else + argarray[j++] = val; + } + + /* Default arguments */ + for (; parm && parm != void_list_node; parm = TREE_CHAIN (parm), i++) + { + if (TREE_VALUE (parm) == error_mark_node) + return error_mark_node; + argarray[j++] = convert_default_arg (TREE_VALUE (parm), + TREE_PURPOSE (parm), + fn, i - is_method, + complain); + } + + /* Ellipsis */ + for (; arg_index < vec_safe_length (args); ++arg_index) + { + tree a = (*args)[arg_index]; + if (magic_varargs_p (fn)) + /* Do no conversions for magic varargs. */ + a = mark_type_use (a); + else + a = convert_arg_to_ellipsis (a, complain); + argarray[j++] = a; + } + + gcc_assert (j <= nargs); + nargs = j; + + check_function_arguments (TREE_TYPE (fn), nargs, argarray); + + /* Avoid actually calling copy constructors and copy assignment operators, + if possible. */ + + if (! flag_elide_constructors) + /* Do things the hard way. */; + else if (cand->num_convs == 1 + && (DECL_COPY_CONSTRUCTOR_P (fn) + || DECL_MOVE_CONSTRUCTOR_P (fn))) + { + tree targ; + tree arg = argarray[num_artificial_parms_for (fn)]; + tree fa; + bool trivial = trivial_fn_p (fn); + + /* Pull out the real argument, disregarding const-correctness. */ + targ = arg; + while (CONVERT_EXPR_P (targ) + || TREE_CODE (targ) == NON_LVALUE_EXPR) + targ = TREE_OPERAND (targ, 0); + if (TREE_CODE (targ) == ADDR_EXPR) + { + targ = TREE_OPERAND (targ, 0); + if (!same_type_ignoring_top_level_qualifiers_p + (TREE_TYPE (TREE_TYPE (arg)), TREE_TYPE (targ))) + targ = NULL_TREE; + } + else + targ = NULL_TREE; + + if (targ) + arg = targ; + else + arg = cp_build_indirect_ref (arg, RO_NULL, complain); + + /* [class.copy]: the copy constructor is implicitly defined even if + the implementation elided its use. */ + if (!trivial || DECL_DELETED_FN (fn)) + { + mark_used (fn); + already_used = true; + } + + /* If we're creating a temp and we already have one, don't create a + new one. If we're not creating a temp but we get one, use + INIT_EXPR to collapse the temp into our target. Otherwise, if the + ctor is trivial, do a bitwise copy with a simple TARGET_EXPR for a + temp or an INIT_EXPR otherwise. */ + fa = argarray[0]; + if (integer_zerop (fa)) + { + if (TREE_CODE (arg) == TARGET_EXPR) + return arg; + else if (trivial) + return force_target_expr (DECL_CONTEXT (fn), arg, complain); + } + else if (TREE_CODE (arg) == TARGET_EXPR || trivial) + { + tree to = stabilize_reference (cp_build_indirect_ref (fa, RO_NULL, + complain)); + + val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg); + return val; + } + } + else if (DECL_OVERLOADED_OPERATOR_P (fn) == NOP_EXPR + && trivial_fn_p (fn) + && !DECL_DELETED_FN (fn)) + { + tree to = stabilize_reference + (cp_build_indirect_ref (argarray[0], RO_NULL, complain)); + tree type = TREE_TYPE (to); + tree as_base = CLASSTYPE_AS_BASE (type); + tree arg = argarray[1]; + + if (is_really_empty_class (type)) + { + /* Avoid copying empty classes. */ + val = build2 (COMPOUND_EXPR, void_type_node, to, arg); + TREE_NO_WARNING (val) = 1; + val = build2 (COMPOUND_EXPR, type, val, to); + TREE_NO_WARNING (val) = 1; + } + else if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base))) + { + arg = cp_build_indirect_ref (arg, RO_NULL, complain); + val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg); + } + else + { + /* We must only copy the non-tail padding parts. */ + tree arg0, arg2, t; + tree array_type, alias_set; + + arg2 = TYPE_SIZE_UNIT (as_base); + arg0 = cp_build_addr_expr (to, complain); + + array_type = build_array_type (char_type_node, + build_index_type + (size_binop (MINUS_EXPR, + arg2, size_int (1)))); + alias_set = build_int_cst (build_pointer_type (type), 0); + t = build2 (MODIFY_EXPR, void_type_node, + build2 (MEM_REF, array_type, arg0, alias_set), + build2 (MEM_REF, array_type, arg, alias_set)); + val = build2 (COMPOUND_EXPR, TREE_TYPE (to), t, to); + TREE_NO_WARNING (val) = 1; + } + + return val; + } + else if (DECL_DESTRUCTOR_P (fn) + && trivial_fn_p (fn) + && !DECL_DELETED_FN (fn)) + return fold_convert (void_type_node, argarray[0]); + /* FIXME handle trivial default constructor, too. */ + + /* For calls to a multi-versioned function, overload resolution + returns the function with the highest target priority, that is, + the version that will checked for dispatching first. If this + version is inlinable, a direct call to this version can be made + otherwise the call should go through the dispatcher. */ + + if (DECL_FUNCTION_VERSIONED (fn) + && (current_function_decl == NULL + || !targetm.target_option.can_inline_p (current_function_decl, fn))) + { + fn = get_function_version_dispatcher (fn); + if (fn == NULL) + return NULL; + if (!already_used) + mark_versions_used (fn); + } + + if (!already_used + && !mark_used (fn)) + return error_mark_node; + + if (DECL_VINDEX (fn) && (flags & LOOKUP_NONVIRTUAL) == 0 + /* Don't mess with virtual lookup in fold_non_dependent_expr; virtual + functions can't be constexpr. */ + && !in_template_function ()) + { + tree t; + tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (argarray[0])), + DECL_CONTEXT (fn), + ba_any, NULL, complain); + gcc_assert (binfo && binfo != error_mark_node); + + /* Warn about deprecated virtual functions now, since we're about + to throw away the decl. */ + if (TREE_DEPRECATED (fn)) + warn_deprecated_use (fn, NULL_TREE); + + argarray[0] = build_base_path (PLUS_EXPR, argarray[0], binfo, 1, + complain); + if (TREE_SIDE_EFFECTS (argarray[0])) + argarray[0] = save_expr (argarray[0]); + t = build_pointer_type (TREE_TYPE (fn)); + if (DECL_CONTEXT (fn) && TYPE_JAVA_INTERFACE (DECL_CONTEXT (fn))) + fn = build_java_interface_fn_ref (fn, argarray[0]); + else + fn = build_vfn_ref (argarray[0], DECL_VINDEX (fn)); + TREE_TYPE (fn) = t; + } + else + { + fn = build_addr_func (fn, complain); + if (fn == error_mark_node) + return error_mark_node; + } + + return build_cxx_call (fn, nargs, argarray, complain|decltype_flag); +} + +/* Build and return a call to FN, using NARGS arguments in ARGARRAY. + This function performs no overload resolution, conversion, or other + high-level operations. */ + +tree +build_cxx_call (tree fn, int nargs, tree *argarray, + tsubst_flags_t complain) +{ + tree fndecl; + int optimize_sav; + + /* Remember roughly where this call is. */ + location_t loc = EXPR_LOC_OR_LOC (fn, input_location); + fn = build_call_a (fn, nargs, argarray); + SET_EXPR_LOCATION (fn, loc); + + fndecl = get_callee_fndecl (fn); + + /* Check that arguments to builtin functions match the expectations. */ + if (fndecl + && DECL_BUILT_IN (fndecl) + && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL + && !check_builtin_function_arguments (fndecl, nargs, argarray)) + return error_mark_node; + + /* If it is a built-in array notation function, then the return type of + the function is the element type of the array passed in as array + notation (i.e. the first parameter of the function). */ + if (flag_cilkplus && TREE_CODE (fn) == CALL_EXPR) + { + enum built_in_function bif = + is_cilkplus_reduce_builtin (CALL_EXPR_FN (fn)); + if (bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ADD + || bif == BUILT_IN_CILKPLUS_SEC_REDUCE_MUL + || bif == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX + || bif == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN + || bif == BUILT_IN_CILKPLUS_SEC_REDUCE + || bif == BUILT_IN_CILKPLUS_SEC_REDUCE_MUTATING) + { + /* for bif == BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_ZERO or + BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_ZERO or + BUILT_IN_CILKPLUS_SEC_REDUCE_ANY_NONZERO or + BUILT_IN_CILKPLUS_SEC_REDUCE_ALL_NONZERO or + BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND or + BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND + The pre-defined return-type is the correct one. */ + tree array_ntn = CALL_EXPR_ARG (fn, 0); + TREE_TYPE (fn) = TREE_TYPE (array_ntn); + return fn; + } + } + + /* Some built-in function calls will be evaluated at compile-time in + fold (). Set optimize to 1 when folding __builtin_constant_p inside + a constexpr function so that fold_builtin_1 doesn't fold it to 0. */ + optimize_sav = optimize; + if (!optimize && fndecl && DECL_IS_BUILTIN_CONSTANT_P (fndecl) + && current_function_decl + && DECL_DECLARED_CONSTEXPR_P (current_function_decl)) + optimize = 1; + fn = fold_if_not_in_template (fn); + optimize = optimize_sav; + + if (VOID_TYPE_P (TREE_TYPE (fn))) + return fn; + + /* 5.2.2/11: If a function call is a prvalue of object type: if the + function call is either the operand of a decltype-specifier or the + right operand of a comma operator that is the operand of a + decltype-specifier, a temporary object is not introduced for the + prvalue. The type of the prvalue may be incomplete. */ + if (!(complain & tf_decltype)) + { + fn = require_complete_type_sfinae (fn, complain); + if (fn == error_mark_node) + return error_mark_node; + + if (MAYBE_CLASS_TYPE_P (TREE_TYPE (fn))) + fn = build_cplus_new (TREE_TYPE (fn), fn, complain); + } + return convert_from_reference (fn); +} + +static GTY(()) tree java_iface_lookup_fn; + +/* Make an expression which yields the address of the Java interface + method FN. This is achieved by generating a call to libjava's + _Jv_LookupInterfaceMethodIdx(). */ + +static tree +build_java_interface_fn_ref (tree fn, tree instance) +{ + tree lookup_fn, method, idx; + tree klass_ref, iface, iface_ref; + int i; + + if (!java_iface_lookup_fn) + { + tree ftype = build_function_type_list (ptr_type_node, + ptr_type_node, ptr_type_node, + java_int_type_node, NULL_TREE); + java_iface_lookup_fn + = add_builtin_function ("_Jv_LookupInterfaceMethodIdx", ftype, + 0, NOT_BUILT_IN, NULL, NULL_TREE); + } + + /* Look up the pointer to the runtime java.lang.Class object for `instance'. + This is the first entry in the vtable. */ + klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, RO_NULL, + tf_warning_or_error), + integer_zero_node); + + /* Get the java.lang.Class pointer for the interface being called. */ + iface = DECL_CONTEXT (fn); + iface_ref = lookup_field (iface, get_identifier ("class$"), 0, false); + if (!iface_ref || !VAR_P (iface_ref) + || DECL_CONTEXT (iface_ref) != iface) + { + error ("could not find class$ field in java interface type %qT", + iface); + return error_mark_node; + } + iface_ref = build_address (iface_ref); + iface_ref = convert (build_pointer_type (iface), iface_ref); + + /* Determine the itable index of FN. */ + i = 1; + for (method = TYPE_METHODS (iface); method; method = DECL_CHAIN (method)) + { + if (!DECL_VIRTUAL_P (method)) + continue; + if (fn == method) + break; + i++; + } + idx = build_int_cst (NULL_TREE, i); + + lookup_fn = build1 (ADDR_EXPR, + build_pointer_type (TREE_TYPE (java_iface_lookup_fn)), + java_iface_lookup_fn); + return build_call_nary (ptr_type_node, lookup_fn, + 3, klass_ref, iface_ref, idx); +} + +/* Returns the value to use for the in-charge parameter when making a + call to a function with the indicated NAME. + + FIXME:Can't we find a neater way to do this mapping? */ + +tree +in_charge_arg_for_name (tree name) +{ + if (name == base_ctor_identifier + || name == base_dtor_identifier) + return integer_zero_node; + else if (name == complete_ctor_identifier) + return integer_one_node; + else if (name == complete_dtor_identifier) + return integer_two_node; + else if (name == deleting_dtor_identifier) + return integer_three_node; + + /* This function should only be called with one of the names listed + above. */ + gcc_unreachable (); + return NULL_TREE; +} + +/* Build a call to a constructor, destructor, or an assignment + operator for INSTANCE, an expression with class type. NAME + indicates the special member function to call; *ARGS are the + arguments. ARGS may be NULL. This may change ARGS. BINFO + indicates the base of INSTANCE that is to be passed as the `this' + parameter to the member function called. + + FLAGS are the LOOKUP_* flags to use when processing the call. + + If NAME indicates a complete object constructor, INSTANCE may be + NULL_TREE. In this case, the caller will call build_cplus_new to + store the newly constructed object into a VAR_DECL. */ + +tree +build_special_member_call (tree instance, tree name, vec<tree, va_gc> **args, + tree binfo, int flags, tsubst_flags_t complain) +{ + tree fns; + /* The type of the subobject to be constructed or destroyed. */ + tree class_type; + vec<tree, va_gc> *allocated = NULL; + tree ret; + + gcc_assert (name == complete_ctor_identifier + || name == base_ctor_identifier + || name == complete_dtor_identifier + || name == base_dtor_identifier + || name == deleting_dtor_identifier + || name == ansi_assopname (NOP_EXPR)); + if (TYPE_P (binfo)) + { + /* Resolve the name. */ + if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain)) + return error_mark_node; + + binfo = TYPE_BINFO (binfo); + } + + gcc_assert (binfo != NULL_TREE); + + class_type = BINFO_TYPE (binfo); + + /* Handle the special case where INSTANCE is NULL_TREE. */ + if (name == complete_ctor_identifier && !instance) + { + instance = build_int_cst (build_pointer_type (class_type), 0); + instance = build1 (INDIRECT_REF, class_type, instance); + } + else + { + if (name == complete_dtor_identifier + || name == base_dtor_identifier + || name == deleting_dtor_identifier) + gcc_assert (args == NULL || vec_safe_is_empty (*args)); + + /* Convert to the base class, if necessary. */ + if (!same_type_ignoring_top_level_qualifiers_p + (TREE_TYPE (instance), BINFO_TYPE (binfo))) + { + if (name != ansi_assopname (NOP_EXPR)) + /* For constructors and destructors, either the base is + non-virtual, or it is virtual but we are doing the + conversion from a constructor or destructor for the + complete object. In either case, we can convert + statically. */ + instance = convert_to_base_statically (instance, binfo); + else + /* However, for assignment operators, we must convert + dynamically if the base is virtual. */ + instance = build_base_path (PLUS_EXPR, instance, + binfo, /*nonnull=*/1, complain); + } + } + + gcc_assert (instance != NULL_TREE); + + fns = lookup_fnfields (binfo, name, 1); + + /* When making a call to a constructor or destructor for a subobject + that uses virtual base classes, pass down a pointer to a VTT for + the subobject. */ + if ((name == base_ctor_identifier + || name == base_dtor_identifier) + && CLASSTYPE_VBASECLASSES (class_type)) + { + tree vtt; + tree sub_vtt; + + /* If the current function is a complete object constructor + or destructor, then we fetch the VTT directly. + Otherwise, we look it up using the VTT we were given. */ + vtt = DECL_CHAIN (CLASSTYPE_VTABLES (current_class_type)); + vtt = decay_conversion (vtt, complain); + if (vtt == error_mark_node) + return error_mark_node; + vtt = build3 (COND_EXPR, TREE_TYPE (vtt), + build2 (EQ_EXPR, boolean_type_node, + current_in_charge_parm, integer_zero_node), + current_vtt_parm, + vtt); + if (BINFO_SUBVTT_INDEX (binfo)) + sub_vtt = fold_build_pointer_plus (vtt, BINFO_SUBVTT_INDEX (binfo)); + else + sub_vtt = vtt; + + if (args == NULL) + { + allocated = make_tree_vector (); + args = &allocated; + } + + vec_safe_insert (*args, 0, sub_vtt); + } + + ret = build_new_method_call (instance, fns, args, + TYPE_BINFO (BINFO_TYPE (binfo)), + flags, /*fn=*/NULL, + complain); + + if (allocated != NULL) + release_tree_vector (allocated); + + if ((complain & tf_error) + && (flags & LOOKUP_DELEGATING_CONS) + && name == complete_ctor_identifier + && TREE_CODE (ret) == CALL_EXPR + && (DECL_ABSTRACT_ORIGIN (TREE_OPERAND (CALL_EXPR_FN (ret), 0)) + == current_function_decl)) + error ("constructor delegates to itself"); + + return ret; +} + +/* Return the NAME, as a C string. The NAME indicates a function that + is a member of TYPE. *FREE_P is set to true if the caller must + free the memory returned. + + Rather than go through all of this, we should simply set the names + of constructors and destructors appropriately, and dispense with + ctor_identifier, dtor_identifier, etc. */ + +static char * +name_as_c_string (tree name, tree type, bool *free_p) +{ + char *pretty_name; + + /* Assume that we will not allocate memory. */ + *free_p = false; + /* Constructors and destructors are special. */ + if (IDENTIFIER_CTOR_OR_DTOR_P (name)) + { + pretty_name + = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (constructor_name (type)))); + /* For a destructor, add the '~'. */ + if (name == complete_dtor_identifier + || name == base_dtor_identifier + || name == deleting_dtor_identifier) + { + pretty_name = concat ("~", pretty_name, NULL); + /* Remember that we need to free the memory allocated. */ + *free_p = true; + } + } + else if (IDENTIFIER_TYPENAME_P (name)) + { + pretty_name = concat ("operator ", + type_as_string_translate (TREE_TYPE (name), + TFF_PLAIN_IDENTIFIER), + NULL); + /* Remember that we need to free the memory allocated. */ + *free_p = true; + } + else + pretty_name = CONST_CAST (char *, identifier_to_locale (IDENTIFIER_POINTER (name))); + + return pretty_name; +} + +/* Build a call to "INSTANCE.FN (ARGS)". If FN_P is non-NULL, it will + be set, upon return, to the function called. ARGS may be NULL. + This may change ARGS. */ + +static tree +build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args, + tree conversion_path, int flags, + tree *fn_p, tsubst_flags_t complain) +{ + struct z_candidate *candidates = 0, *cand; + tree explicit_targs = NULL_TREE; + tree basetype = NULL_TREE; + tree access_binfo, binfo; + tree optype; + tree first_mem_arg = NULL_TREE; + tree name; + bool skip_first_for_error; + vec<tree, va_gc> *user_args; + tree call; + tree fn; + int template_only = 0; + bool any_viable_p; + tree orig_instance; + tree orig_fns; + vec<tree, va_gc> *orig_args = NULL; + void *p; + + gcc_assert (instance != NULL_TREE); + + /* We don't know what function we're going to call, yet. */ + if (fn_p) + *fn_p = NULL_TREE; + + if (error_operand_p (instance) + || !fns || error_operand_p (fns)) + return error_mark_node; + + if (!BASELINK_P (fns)) + { + if (complain & tf_error) + error ("call to non-function %qD", fns); + return error_mark_node; + } + + orig_instance = instance; + orig_fns = fns; + + /* Dismantle the baselink to collect all the information we need. */ + if (!conversion_path) + conversion_path = BASELINK_BINFO (fns); + access_binfo = BASELINK_ACCESS_BINFO (fns); + binfo = BASELINK_BINFO (fns); + optype = BASELINK_OPTYPE (fns); + fns = BASELINK_FUNCTIONS (fns); + if (TREE_CODE (fns) == TEMPLATE_ID_EXPR) + { + explicit_targs = TREE_OPERAND (fns, 1); + fns = TREE_OPERAND (fns, 0); + template_only = 1; + } + gcc_assert (TREE_CODE (fns) == FUNCTION_DECL + || TREE_CODE (fns) == TEMPLATE_DECL + || TREE_CODE (fns) == OVERLOAD); + fn = get_first_fn (fns); + name = DECL_NAME (fn); + + basetype = TYPE_MAIN_VARIANT (TREE_TYPE (instance)); + gcc_assert (CLASS_TYPE_P (basetype)); + + if (processing_template_decl) + { + orig_args = args == NULL ? NULL : make_tree_vector_copy (*args); + instance = build_non_dependent_expr (instance); + if (args != NULL) + make_args_non_dependent (*args); + } + + user_args = args == NULL ? NULL : *args; + /* Under DR 147 A::A() is an invalid constructor call, + not a functional cast. */ + if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)) + { + if (! (complain & tf_error)) + return error_mark_node; + + if (permerror (input_location, + "cannot call constructor %<%T::%D%> directly", + basetype, name)) + inform (input_location, "for a function-style cast, remove the " + "redundant %<::%D%>", name); + call = build_functional_cast (basetype, build_tree_list_vec (user_args), + complain); + return call; + } + + /* Figure out whether to skip the first argument for the error + message we will display to users if an error occurs. We don't + want to display any compiler-generated arguments. The "this" + pointer hasn't been added yet. However, we must remove the VTT + pointer if this is a call to a base-class constructor or + destructor. */ + skip_first_for_error = false; + if (IDENTIFIER_CTOR_OR_DTOR_P (name)) + { + /* Callers should explicitly indicate whether they want to construct + the complete object or just the part without virtual bases. */ + gcc_assert (name != ctor_identifier); + /* Similarly for destructors. */ + gcc_assert (name != dtor_identifier); + /* Remove the VTT pointer, if present. */ + if ((name == base_ctor_identifier || name == base_dtor_identifier) + && CLASSTYPE_VBASECLASSES (basetype)) + skip_first_for_error = true; + } + + /* Process the argument list. */ + if (args != NULL && *args != NULL) + { + *args = resolve_args (*args, complain); + if (*args == NULL) + return error_mark_node; + } + + /* Consider the object argument to be used even if we end up selecting a + static member function. */ + instance = mark_type_use (instance); + + /* It's OK to call destructors and constructors on cv-qualified objects. + Therefore, convert the INSTANCE to the unqualified type, if + necessary. */ + if (DECL_DESTRUCTOR_P (fn) + || DECL_CONSTRUCTOR_P (fn)) + { + if (!same_type_p (basetype, TREE_TYPE (instance))) + { + instance = build_this (instance); + instance = build_nop (build_pointer_type (basetype), instance); + instance = build_fold_indirect_ref (instance); + } + } + if (DECL_DESTRUCTOR_P (fn)) + name = complete_dtor_identifier; + + first_mem_arg = instance; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + /* If CONSTRUCTOR_IS_DIRECT_INIT is set, this was a T{ } form + initializer, not T({ }). */ + if (DECL_CONSTRUCTOR_P (fn) && args != NULL && !vec_safe_is_empty (*args) + && BRACE_ENCLOSED_INITIALIZER_P ((**args)[0]) + && CONSTRUCTOR_IS_DIRECT_INIT ((**args)[0])) + { + tree init_list = (**args)[0]; + tree init = NULL_TREE; + + gcc_assert ((*args)->length () == 1 + && !(flags & LOOKUP_ONLYCONVERTING)); + + /* If the initializer list has no elements and T is a class type with + a default constructor, the object is value-initialized. Handle + this here so we don't need to handle it wherever we use + build_special_member_call. */ + if (CONSTRUCTOR_NELTS (init_list) == 0 + && TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype) + /* For a user-provided default constructor, use the normal + mechanisms so that protected access works. */ + && !type_has_user_provided_default_constructor (basetype) + && !processing_template_decl) + init = build_value_init (basetype, complain); + + /* If BASETYPE is an aggregate, we need to do aggregate + initialization. */ + else if (CP_AGGREGATE_TYPE_P (basetype)) + init = digest_init (basetype, init_list, complain); + + if (init) + { + if (INDIRECT_REF_P (instance) + && integer_zerop (TREE_OPERAND (instance, 0))) + return get_target_expr_sfinae (init, complain); + init = build2 (INIT_EXPR, TREE_TYPE (instance), instance, init); + TREE_SIDE_EFFECTS (init) = true; + return init; + } + + /* Otherwise go ahead with overload resolution. */ + add_list_candidates (fns, first_mem_arg, init_list, + basetype, explicit_targs, template_only, + conversion_path, access_binfo, flags, + &candidates, complain); + } + else + { + add_candidates (fns, first_mem_arg, user_args, optype, + explicit_targs, template_only, conversion_path, + access_binfo, flags, &candidates, complain); + } + any_viable_p = false; + candidates = splice_viable (candidates, pedantic, &any_viable_p); + + if (!any_viable_p) + { + if (complain & tf_error) + { + if (!COMPLETE_OR_OPEN_TYPE_P (basetype)) + cxx_incomplete_type_error (instance, basetype); + else if (optype) + error ("no matching function for call to %<%T::operator %T(%A)%#V%>", + basetype, optype, build_tree_list_vec (user_args), + TREE_TYPE (instance)); + else + { + char *pretty_name; + bool free_p; + tree arglist; + + pretty_name = name_as_c_string (name, basetype, &free_p); + arglist = build_tree_list_vec (user_args); + if (skip_first_for_error) + arglist = TREE_CHAIN (arglist); + error ("no matching function for call to %<%T::%s(%A)%#V%>", + basetype, pretty_name, arglist, + TREE_TYPE (instance)); + if (free_p) + free (pretty_name); + } + print_z_candidates (location_of (name), candidates); + } + call = error_mark_node; + } + else + { + cand = tourney (candidates, complain); + if (cand == 0) + { + char *pretty_name; + bool free_p; + tree arglist; + + if (complain & tf_error) + { + pretty_name = name_as_c_string (name, basetype, &free_p); + arglist = build_tree_list_vec (user_args); + if (skip_first_for_error) + arglist = TREE_CHAIN (arglist); + error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name, + arglist); + print_z_candidates (location_of (name), candidates); + if (free_p) + free (pretty_name); + } + call = error_mark_node; + } + else + { + fn = cand->fn; + call = NULL_TREE; + + if (!(flags & LOOKUP_NONVIRTUAL) + && DECL_PURE_VIRTUAL_P (fn) + && instance == current_class_ref + && (complain & tf_warning)) + { + /* This is not an error, it is runtime undefined + behavior. */ + if (!current_function_decl) + warning (0, "pure virtual %q#D called from " + "non-static data member initializer", fn); + else if (DECL_CONSTRUCTOR_P (current_function_decl) + || DECL_DESTRUCTOR_P (current_function_decl)) + warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) + ? "pure virtual %q#D called from constructor" + : "pure virtual %q#D called from destructor"), + fn); + } + + if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE + && is_dummy_object (instance)) + { + instance = maybe_resolve_dummy (instance); + if (instance == error_mark_node) + call = error_mark_node; + else if (!is_dummy_object (instance)) + { + /* We captured 'this' in the current lambda now that + we know we really need it. */ + cand->first_arg = instance; + } + else + { + if (complain & tf_error) + error ("cannot call member function %qD without object", + fn); + call = error_mark_node; + } + } + + if (call != error_mark_node) + { + /* Optimize away vtable lookup if we know that this + function can't be overridden. We need to check if + the context and the type where we found fn are the same, + actually FN might be defined in a different class + type because of a using-declaration. In this case, we + do not want to perform a non-virtual call. */ + if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL) + && same_type_ignoring_top_level_qualifiers_p + (DECL_CONTEXT (fn), BINFO_TYPE (binfo)) + && resolves_to_fixed_type_p (instance, 0)) + flags |= LOOKUP_NONVIRTUAL; + if (explicit_targs) + flags |= LOOKUP_EXPLICIT_TMPL_ARGS; + /* Now we know what function is being called. */ + if (fn_p) + *fn_p = fn; + /* Build the actual CALL_EXPR. */ + call = build_over_call (cand, flags, complain); + /* In an expression of the form `a->f()' where `f' turns + out to be a static member function, `a' is + none-the-less evaluated. */ + if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE + && !is_dummy_object (instance) + && TREE_SIDE_EFFECTS (instance)) + call = build2 (COMPOUND_EXPR, TREE_TYPE (call), + instance, call); + else if (call != error_mark_node + && DECL_DESTRUCTOR_P (cand->fn) + && !VOID_TYPE_P (TREE_TYPE (call))) + /* An explicit call of the form "x->~X()" has type + "void". However, on platforms where destructors + return "this" (i.e., those where + targetm.cxx.cdtor_returns_this is true), such calls + will appear to have a return value of pointer type + to the low-level call machinery. We do not want to + change the low-level machinery, since we want to be + able to optimize "delete f()" on such platforms as + "operator delete(~X(f()))" (rather than generating + "t = f(), ~X(t), operator delete (t)"). */ + call = build_nop (void_type_node, call); + } + } + } + + if (processing_template_decl && call != error_mark_node) + { + bool cast_to_void = false; + + if (TREE_CODE (call) == COMPOUND_EXPR) + call = TREE_OPERAND (call, 1); + else if (TREE_CODE (call) == NOP_EXPR) + { + cast_to_void = true; + call = TREE_OPERAND (call, 0); + } + if (INDIRECT_REF_P (call)) + call = TREE_OPERAND (call, 0); + call = (build_min_non_dep_call_vec + (call, + build_min (COMPONENT_REF, TREE_TYPE (CALL_EXPR_FN (call)), + orig_instance, orig_fns, NULL_TREE), + orig_args)); + SET_EXPR_LOCATION (call, input_location); + call = convert_from_reference (call); + if (cast_to_void) + call = build_nop (void_type_node, call); + } + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + if (orig_args != NULL) + release_tree_vector (orig_args); + + return call; +} + +/* Wrapper for above. */ + +tree +build_new_method_call (tree instance, tree fns, vec<tree, va_gc> **args, + tree conversion_path, int flags, + tree *fn_p, tsubst_flags_t complain) +{ + tree ret; + bool subtime = timevar_cond_start (TV_OVERLOAD); + ret = build_new_method_call_1 (instance, fns, args, conversion_path, flags, + fn_p, complain); + timevar_cond_stop (TV_OVERLOAD, subtime); + return ret; +} + +/* Returns true iff standard conversion sequence ICS1 is a proper + subsequence of ICS2. */ + +static bool +is_subseq (conversion *ics1, conversion *ics2) +{ + /* We can assume that a conversion of the same code + between the same types indicates a subsequence since we only get + here if the types we are converting from are the same. */ + + while (ics1->kind == ck_rvalue + || ics1->kind == ck_lvalue) + ics1 = next_conversion (ics1); + + while (1) + { + while (ics2->kind == ck_rvalue + || ics2->kind == ck_lvalue) + ics2 = next_conversion (ics2); + + if (ics2->kind == ck_user + || ics2->kind == ck_ambig + || ics2->kind == ck_aggr + || ics2->kind == ck_list + || ics2->kind == ck_identity) + /* At this point, ICS1 cannot be a proper subsequence of + ICS2. We can get a USER_CONV when we are comparing the + second standard conversion sequence of two user conversion + sequences. */ + return false; + + ics2 = next_conversion (ics2); + + if (ics2->kind == ics1->kind + && same_type_p (ics2->type, ics1->type) + && same_type_p (next_conversion (ics2)->type, + next_conversion (ics1)->type)) + return true; + } +} + +/* Returns nonzero iff DERIVED is derived from BASE. The inputs may + be any _TYPE nodes. */ + +bool +is_properly_derived_from (tree derived, tree base) +{ + if (!CLASS_TYPE_P (derived) || !CLASS_TYPE_P (base)) + return false; + + /* We only allow proper derivation here. The DERIVED_FROM_P macro + considers every class derived from itself. */ + return (!same_type_ignoring_top_level_qualifiers_p (derived, base) + && DERIVED_FROM_P (base, derived)); +} + +/* We build the ICS for an implicit object parameter as a pointer + conversion sequence. However, such a sequence should be compared + as if it were a reference conversion sequence. If ICS is the + implicit conversion sequence for an implicit object parameter, + modify it accordingly. */ + +static void +maybe_handle_implicit_object (conversion **ics) +{ + if ((*ics)->this_p) + { + /* [over.match.funcs] + + For non-static member functions, the type of the + implicit object parameter is "reference to cv X" + where X is the class of which the function is a + member and cv is the cv-qualification on the member + function declaration. */ + conversion *t = *ics; + tree reference_type; + + /* The `this' parameter is a pointer to a class type. Make the + implicit conversion talk about a reference to that same class + type. */ + reference_type = TREE_TYPE (t->type); + reference_type = build_reference_type (reference_type); + + if (t->kind == ck_qual) + t = next_conversion (t); + if (t->kind == ck_ptr) + t = next_conversion (t); + t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE); + t = direct_reference_binding (reference_type, t); + t->this_p = 1; + t->rvaluedness_matches_p = 0; + *ics = t; + } +} + +/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion, + and return the initial reference binding conversion. Otherwise, + leave *ICS unchanged and return NULL. */ + +static conversion * +maybe_handle_ref_bind (conversion **ics) +{ + if ((*ics)->kind == ck_ref_bind) + { + conversion *old_ics = *ics; + *ics = next_conversion (old_ics); + (*ics)->user_conv_p = old_ics->user_conv_p; + return old_ics; + } + + return NULL; +} + +/* Compare two implicit conversion sequences according to the rules set out in + [over.ics.rank]. Return values: + + 1: ics1 is better than ics2 + -1: ics2 is better than ics1 + 0: ics1 and ics2 are indistinguishable */ + +static int +compare_ics (conversion *ics1, conversion *ics2) +{ + tree from_type1; + tree from_type2; + tree to_type1; + tree to_type2; + tree deref_from_type1 = NULL_TREE; + tree deref_from_type2 = NULL_TREE; + tree deref_to_type1 = NULL_TREE; + tree deref_to_type2 = NULL_TREE; + conversion_rank rank1, rank2; + + /* REF_BINDING is nonzero if the result of the conversion sequence + is a reference type. In that case REF_CONV is the reference + binding conversion. */ + conversion *ref_conv1; + conversion *ref_conv2; + + /* Handle implicit object parameters. */ + maybe_handle_implicit_object (&ics1); + maybe_handle_implicit_object (&ics2); + + /* Handle reference parameters. */ + ref_conv1 = maybe_handle_ref_bind (&ics1); + ref_conv2 = maybe_handle_ref_bind (&ics2); + + /* List-initialization sequence L1 is a better conversion sequence than + list-initialization sequence L2 if L1 converts to + std::initializer_list<X> for some X and L2 does not. */ + if (ics1->kind == ck_list && ics2->kind != ck_list) + return 1; + if (ics2->kind == ck_list && ics1->kind != ck_list) + return -1; + + /* [over.ics.rank] + + When comparing the basic forms of implicit conversion sequences (as + defined in _over.best.ics_) + + --a standard conversion sequence (_over.ics.scs_) is a better + conversion sequence than a user-defined conversion sequence + or an ellipsis conversion sequence, and + + --a user-defined conversion sequence (_over.ics.user_) is a + better conversion sequence than an ellipsis conversion sequence + (_over.ics.ellipsis_). */ + rank1 = CONVERSION_RANK (ics1); + rank2 = CONVERSION_RANK (ics2); + + if (rank1 > rank2) + return -1; + else if (rank1 < rank2) + return 1; + + if (rank1 == cr_bad) + { + /* Both ICS are bad. We try to make a decision based on what would + have happened if they'd been good. This is not an extension, + we'll still give an error when we build up the call; this just + helps us give a more helpful error message. */ + rank1 = BAD_CONVERSION_RANK (ics1); + rank2 = BAD_CONVERSION_RANK (ics2); + + if (rank1 > rank2) + return -1; + else if (rank1 < rank2) + return 1; + + /* We couldn't make up our minds; try to figure it out below. */ + } + + if (ics1->ellipsis_p) + /* Both conversions are ellipsis conversions. */ + return 0; + + /* User-defined conversion sequence U1 is a better conversion sequence + than another user-defined conversion sequence U2 if they contain the + same user-defined conversion operator or constructor and if the sec- + ond standard conversion sequence of U1 is better than the second + standard conversion sequence of U2. */ + + /* Handle list-conversion with the same code even though it isn't always + ranked as a user-defined conversion and it doesn't have a second + standard conversion sequence; it will still have the desired effect. + Specifically, we need to do the reference binding comparison at the + end of this function. */ + + if (ics1->user_conv_p || ics1->kind == ck_list || ics1->kind == ck_aggr) + { + conversion *t1; + conversion *t2; + + for (t1 = ics1; t1->kind != ck_user; t1 = next_conversion (t1)) + if (t1->kind == ck_ambig || t1->kind == ck_aggr + || t1->kind == ck_list) + break; + for (t2 = ics2; t2->kind != ck_user; t2 = next_conversion (t2)) + if (t2->kind == ck_ambig || t2->kind == ck_aggr + || t2->kind == ck_list) + break; + + if (t1->kind != t2->kind) + return 0; + else if (t1->kind == ck_user) + { + if (t1->cand->fn != t2->cand->fn) + return 0; + } + else + { + /* For ambiguous or aggregate conversions, use the target type as + a proxy for the conversion function. */ + if (!same_type_ignoring_top_level_qualifiers_p (t1->type, t2->type)) + return 0; + } + + /* We can just fall through here, after setting up + FROM_TYPE1 and FROM_TYPE2. */ + from_type1 = t1->type; + from_type2 = t2->type; + } + else + { + conversion *t1; + conversion *t2; + + /* We're dealing with two standard conversion sequences. + + [over.ics.rank] + + Standard conversion sequence S1 is a better conversion + sequence than standard conversion sequence S2 if + + --S1 is a proper subsequence of S2 (comparing the conversion + sequences in the canonical form defined by _over.ics.scs_, + excluding any Lvalue Transformation; the identity + conversion sequence is considered to be a subsequence of + any non-identity conversion sequence */ + + t1 = ics1; + while (t1->kind != ck_identity) + t1 = next_conversion (t1); + from_type1 = t1->type; + + t2 = ics2; + while (t2->kind != ck_identity) + t2 = next_conversion (t2); + from_type2 = t2->type; + } + + /* One sequence can only be a subsequence of the other if they start with + the same type. They can start with different types when comparing the + second standard conversion sequence in two user-defined conversion + sequences. */ + if (same_type_p (from_type1, from_type2)) + { + if (is_subseq (ics1, ics2)) + return 1; + if (is_subseq (ics2, ics1)) + return -1; + } + + /* [over.ics.rank] + + Or, if not that, + + --the rank of S1 is better than the rank of S2 (by the rules + defined below): + + Standard conversion sequences are ordered by their ranks: an Exact + Match is a better conversion than a Promotion, which is a better + conversion than a Conversion. + + Two conversion sequences with the same rank are indistinguishable + unless one of the following rules applies: + + --A conversion that does not a convert a pointer, pointer to member, + or std::nullptr_t to bool is better than one that does. + + The ICS_STD_RANK automatically handles the pointer-to-bool rule, + so that we do not have to check it explicitly. */ + if (ics1->rank < ics2->rank) + return 1; + else if (ics2->rank < ics1->rank) + return -1; + + to_type1 = ics1->type; + to_type2 = ics2->type; + + /* A conversion from scalar arithmetic type to complex is worse than a + conversion between scalar arithmetic types. */ + if (same_type_p (from_type1, from_type2) + && ARITHMETIC_TYPE_P (from_type1) + && ARITHMETIC_TYPE_P (to_type1) + && ARITHMETIC_TYPE_P (to_type2) + && ((TREE_CODE (to_type1) == COMPLEX_TYPE) + != (TREE_CODE (to_type2) == COMPLEX_TYPE))) + { + if (TREE_CODE (to_type1) == COMPLEX_TYPE) + return -1; + else + return 1; + } + + if (TYPE_PTR_P (from_type1) + && TYPE_PTR_P (from_type2) + && TYPE_PTR_P (to_type1) + && TYPE_PTR_P (to_type2)) + { + deref_from_type1 = TREE_TYPE (from_type1); + deref_from_type2 = TREE_TYPE (from_type2); + deref_to_type1 = TREE_TYPE (to_type1); + deref_to_type2 = TREE_TYPE (to_type2); + } + /* The rules for pointers to members A::* are just like the rules + for pointers A*, except opposite: if B is derived from A then + A::* converts to B::*, not vice versa. For that reason, we + switch the from_ and to_ variables here. */ + else if ((TYPE_PTRDATAMEM_P (from_type1) && TYPE_PTRDATAMEM_P (from_type2) + && TYPE_PTRDATAMEM_P (to_type1) && TYPE_PTRDATAMEM_P (to_type2)) + || (TYPE_PTRMEMFUNC_P (from_type1) + && TYPE_PTRMEMFUNC_P (from_type2) + && TYPE_PTRMEMFUNC_P (to_type1) + && TYPE_PTRMEMFUNC_P (to_type2))) + { + deref_to_type1 = TYPE_PTRMEM_CLASS_TYPE (from_type1); + deref_to_type2 = TYPE_PTRMEM_CLASS_TYPE (from_type2); + deref_from_type1 = TYPE_PTRMEM_CLASS_TYPE (to_type1); + deref_from_type2 = TYPE_PTRMEM_CLASS_TYPE (to_type2); + } + + if (deref_from_type1 != NULL_TREE + && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type1)) + && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_from_type2))) + { + /* This was one of the pointer or pointer-like conversions. + + [over.ics.rank] + + --If class B is derived directly or indirectly from class A, + conversion of B* to A* is better than conversion of B* to + void*, and conversion of A* to void* is better than + conversion of B* to void*. */ + if (VOID_TYPE_P (deref_to_type1) + && VOID_TYPE_P (deref_to_type2)) + { + if (is_properly_derived_from (deref_from_type1, + deref_from_type2)) + return -1; + else if (is_properly_derived_from (deref_from_type2, + deref_from_type1)) + return 1; + } + else if (VOID_TYPE_P (deref_to_type1) + || VOID_TYPE_P (deref_to_type2)) + { + if (same_type_p (deref_from_type1, deref_from_type2)) + { + if (VOID_TYPE_P (deref_to_type2)) + { + if (is_properly_derived_from (deref_from_type1, + deref_to_type1)) + return 1; + } + /* We know that DEREF_TO_TYPE1 is `void' here. */ + else if (is_properly_derived_from (deref_from_type1, + deref_to_type2)) + return -1; + } + } + else if (RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type1)) + && RECORD_OR_UNION_CODE_P (TREE_CODE (deref_to_type2))) + { + /* [over.ics.rank] + + --If class B is derived directly or indirectly from class A + and class C is derived directly or indirectly from B, + + --conversion of C* to B* is better than conversion of C* to + A*, + + --conversion of B* to A* is better than conversion of C* to + A* */ + if (same_type_p (deref_from_type1, deref_from_type2)) + { + if (is_properly_derived_from (deref_to_type1, + deref_to_type2)) + return 1; + else if (is_properly_derived_from (deref_to_type2, + deref_to_type1)) + return -1; + } + else if (same_type_p (deref_to_type1, deref_to_type2)) + { + if (is_properly_derived_from (deref_from_type2, + deref_from_type1)) + return 1; + else if (is_properly_derived_from (deref_from_type1, + deref_from_type2)) + return -1; + } + } + } + else if (CLASS_TYPE_P (non_reference (from_type1)) + && same_type_p (from_type1, from_type2)) + { + tree from = non_reference (from_type1); + + /* [over.ics.rank] + + --binding of an expression of type C to a reference of type + B& is better than binding an expression of type C to a + reference of type A& + + --conversion of C to B is better than conversion of C to A, */ + if (is_properly_derived_from (from, to_type1) + && is_properly_derived_from (from, to_type2)) + { + if (is_properly_derived_from (to_type1, to_type2)) + return 1; + else if (is_properly_derived_from (to_type2, to_type1)) + return -1; + } + } + else if (CLASS_TYPE_P (non_reference (to_type1)) + && same_type_p (to_type1, to_type2)) + { + tree to = non_reference (to_type1); + + /* [over.ics.rank] + + --binding of an expression of type B to a reference of type + A& is better than binding an expression of type C to a + reference of type A&, + + --conversion of B to A is better than conversion of C to A */ + if (is_properly_derived_from (from_type1, to) + && is_properly_derived_from (from_type2, to)) + { + if (is_properly_derived_from (from_type2, from_type1)) + return 1; + else if (is_properly_derived_from (from_type1, from_type2)) + return -1; + } + } + + /* [over.ics.rank] + + --S1 and S2 differ only in their qualification conversion and yield + similar types T1 and T2 (_conv.qual_), respectively, and the cv- + qualification signature of type T1 is a proper subset of the cv- + qualification signature of type T2 */ + if (ics1->kind == ck_qual + && ics2->kind == ck_qual + && same_type_p (from_type1, from_type2)) + { + int result = comp_cv_qual_signature (to_type1, to_type2); + if (result != 0) + return result; + } + + /* [over.ics.rank] + + --S1 and S2 are reference bindings (_dcl.init.ref_) and neither refers + to an implicit object parameter, and either S1 binds an lvalue reference + to an lvalue and S2 binds an rvalue reference or S1 binds an rvalue + reference to an rvalue and S2 binds an lvalue reference + (C++0x draft standard, 13.3.3.2) + + --S1 and S2 are reference bindings (_dcl.init.ref_), and the + types to which the references refer are the same type except for + top-level cv-qualifiers, and the type to which the reference + initialized by S2 refers is more cv-qualified than the type to + which the reference initialized by S1 refers. + + DR 1328 [over.match.best]: the context is an initialization by + conversion function for direct reference binding (13.3.1.6) of a + reference to function type, the return type of F1 is the same kind of + reference (i.e. lvalue or rvalue) as the reference being initialized, + and the return type of F2 is not. */ + + if (ref_conv1 && ref_conv2) + { + if (!ref_conv1->this_p && !ref_conv2->this_p + && (ref_conv1->rvaluedness_matches_p + != ref_conv2->rvaluedness_matches_p) + && (same_type_p (ref_conv1->type, ref_conv2->type) + || (TYPE_REF_IS_RVALUE (ref_conv1->type) + != TYPE_REF_IS_RVALUE (ref_conv2->type)))) + { + return (ref_conv1->rvaluedness_matches_p + - ref_conv2->rvaluedness_matches_p); + } + + if (same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2)) + return comp_cv_qualification (TREE_TYPE (ref_conv2->type), + TREE_TYPE (ref_conv1->type)); + } + + /* Neither conversion sequence is better than the other. */ + return 0; +} + +/* The source type for this standard conversion sequence. */ + +static tree +source_type (conversion *t) +{ + for (;; t = next_conversion (t)) + { + if (t->kind == ck_user + || t->kind == ck_ambig + || t->kind == ck_identity) + return t->type; + } + gcc_unreachable (); +} + +/* Note a warning about preferring WINNER to LOSER. We do this by storing + a pointer to LOSER and re-running joust to produce the warning if WINNER + is actually used. */ + +static void +add_warning (struct z_candidate *winner, struct z_candidate *loser) +{ + candidate_warning *cw = (candidate_warning *) + conversion_obstack_alloc (sizeof (candidate_warning)); + cw->loser = loser; + cw->next = winner->warnings; + winner->warnings = cw; +} + +/* Compare two candidates for overloading as described in + [over.match.best]. Return values: + + 1: cand1 is better than cand2 + -1: cand2 is better than cand1 + 0: cand1 and cand2 are indistinguishable */ + +static int +joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn, + tsubst_flags_t complain) +{ + int winner = 0; + int off1 = 0, off2 = 0; + size_t i; + size_t len; + + /* Candidates that involve bad conversions are always worse than those + that don't. */ + if (cand1->viable > cand2->viable) + return 1; + if (cand1->viable < cand2->viable) + return -1; + + /* If we have two pseudo-candidates for conversions to the same type, + or two candidates for the same function, arbitrarily pick one. */ + if (cand1->fn == cand2->fn + && (IS_TYPE_OR_DECL_P (cand1->fn))) + return 1; + + /* Prefer a non-deleted function over an implicitly deleted move + constructor or assignment operator. This differs slightly from the + wording for issue 1402 (which says the move op is ignored by overload + resolution), but this way produces better error messages. */ + if (TREE_CODE (cand1->fn) == FUNCTION_DECL + && TREE_CODE (cand2->fn) == FUNCTION_DECL + && DECL_DELETED_FN (cand1->fn) != DECL_DELETED_FN (cand2->fn)) + { + if (DECL_DELETED_FN (cand1->fn) && DECL_DEFAULTED_FN (cand1->fn) + && move_fn_p (cand1->fn)) + return -1; + if (DECL_DELETED_FN (cand2->fn) && DECL_DEFAULTED_FN (cand2->fn) + && move_fn_p (cand2->fn)) + return 1; + } + + /* a viable function F1 + is defined to be a better function than another viable function F2 if + for all arguments i, ICSi(F1) is not a worse conversion sequence than + ICSi(F2), and then */ + + /* for some argument j, ICSj(F1) is a better conversion sequence than + ICSj(F2) */ + + /* For comparing static and non-static member functions, we ignore + the implicit object parameter of the non-static function. The + standard says to pretend that the static function has an object + parm, but that won't work with operator overloading. */ + len = cand1->num_convs; + if (len != cand2->num_convs) + { + int static_1 = DECL_STATIC_FUNCTION_P (cand1->fn); + int static_2 = DECL_STATIC_FUNCTION_P (cand2->fn); + + if (DECL_CONSTRUCTOR_P (cand1->fn) + && is_list_ctor (cand1->fn) != is_list_ctor (cand2->fn)) + /* We're comparing a near-match list constructor and a near-match + non-list constructor. Just treat them as unordered. */ + return 0; + + gcc_assert (static_1 != static_2); + + if (static_1) + off2 = 1; + else + { + off1 = 1; + --len; + } + } + + for (i = 0; i < len; ++i) + { + conversion *t1 = cand1->convs[i + off1]; + conversion *t2 = cand2->convs[i + off2]; + int comp = compare_ics (t1, t2); + + if (comp != 0) + { + if ((complain & tf_warning) + && warn_sign_promo + && (CONVERSION_RANK (t1) + CONVERSION_RANK (t2) + == cr_std + cr_promotion) + && t1->kind == ck_std + && t2->kind == ck_std + && TREE_CODE (t1->type) == INTEGER_TYPE + && TREE_CODE (t2->type) == INTEGER_TYPE + && (TYPE_PRECISION (t1->type) + == TYPE_PRECISION (t2->type)) + && (TYPE_UNSIGNED (next_conversion (t1)->type) + || (TREE_CODE (next_conversion (t1)->type) + == ENUMERAL_TYPE))) + { + tree type = next_conversion (t1)->type; + tree type1, type2; + struct z_candidate *w, *l; + if (comp > 0) + type1 = t1->type, type2 = t2->type, + w = cand1, l = cand2; + else + type1 = t2->type, type2 = t1->type, + w = cand2, l = cand1; + + if (warn) + { + warning (OPT_Wsign_promo, "passing %qT chooses %qT over %qT", + type, type1, type2); + warning (OPT_Wsign_promo, " in call to %qD", w->fn); + } + else + add_warning (w, l); + } + + if (winner && comp != winner) + { + winner = 0; + goto tweak; + } + winner = comp; + } + } + + /* warn about confusing overload resolution for user-defined conversions, + either between a constructor and a conversion op, or between two + conversion ops. */ + if ((complain & tf_warning) + && winner && warn_conversion && cand1->second_conv + && (!DECL_CONSTRUCTOR_P (cand1->fn) || !DECL_CONSTRUCTOR_P (cand2->fn)) + && winner != compare_ics (cand1->second_conv, cand2->second_conv)) + { + struct z_candidate *w, *l; + bool give_warning = false; + + if (winner == 1) + w = cand1, l = cand2; + else + w = cand2, l = cand1; + + /* We don't want to complain about `X::operator T1 ()' + beating `X::operator T2 () const', when T2 is a no less + cv-qualified version of T1. */ + if (DECL_CONTEXT (w->fn) == DECL_CONTEXT (l->fn) + && !DECL_CONSTRUCTOR_P (w->fn) && !DECL_CONSTRUCTOR_P (l->fn)) + { + tree t = TREE_TYPE (TREE_TYPE (l->fn)); + tree f = TREE_TYPE (TREE_TYPE (w->fn)); + + if (TREE_CODE (t) == TREE_CODE (f) && POINTER_TYPE_P (t)) + { + t = TREE_TYPE (t); + f = TREE_TYPE (f); + } + if (!comp_ptr_ttypes (t, f)) + give_warning = true; + } + else + give_warning = true; + + if (!give_warning) + /*NOP*/; + else if (warn) + { + tree source = source_type (w->convs[0]); + if (! DECL_CONSTRUCTOR_P (w->fn)) + source = TREE_TYPE (source); + if (warning (OPT_Wconversion, "choosing %qD over %qD", w->fn, l->fn) + && warning (OPT_Wconversion, " for conversion from %qT to %qT", + source, w->second_conv->type)) + { + inform (input_location, " because conversion sequence for the argument is better"); + } + } + else + add_warning (w, l); + } + + if (winner) + return winner; + + /* DR 495 moved this tiebreaker above the template ones. */ + /* or, if not that, + the context is an initialization by user-defined conversion (see + _dcl.init_ and _over.match.user_) and the standard conversion + sequence from the return type of F1 to the destination type (i.e., + the type of the entity being initialized) is a better conversion + sequence than the standard conversion sequence from the return type + of F2 to the destination type. */ + + if (cand1->second_conv) + { + winner = compare_ics (cand1->second_conv, cand2->second_conv); + if (winner) + return winner; + } + + /* or, if not that, + F1 is a non-template function and F2 is a template function + specialization. */ + + if (!cand1->template_decl && cand2->template_decl) + return 1; + else if (cand1->template_decl && !cand2->template_decl) + return -1; + + /* or, if not that, + F1 and F2 are template functions and the function template for F1 is + more specialized than the template for F2 according to the partial + ordering rules. */ + + if (cand1->template_decl && cand2->template_decl) + { + winner = more_specialized_fn + (TI_TEMPLATE (cand1->template_decl), + TI_TEMPLATE (cand2->template_decl), + /* [temp.func.order]: The presence of unused ellipsis and default + arguments has no effect on the partial ordering of function + templates. add_function_candidate() will not have + counted the "this" argument for constructors. */ + cand1->num_convs + DECL_CONSTRUCTOR_P (cand1->fn)); + if (winner) + return winner; + } + + /* Check whether we can discard a builtin candidate, either because we + have two identical ones or matching builtin and non-builtin candidates. + + (Pedantically in the latter case the builtin which matched the user + function should not be added to the overload set, but we spot it here. + + [over.match.oper] + ... the builtin candidates include ... + - do not have the same parameter type list as any non-template + non-member candidate. */ + + if (identifier_p (cand1->fn) || identifier_p (cand2->fn)) + { + for (i = 0; i < len; ++i) + if (!same_type_p (cand1->convs[i]->type, + cand2->convs[i]->type)) + break; + if (i == cand1->num_convs) + { + if (cand1->fn == cand2->fn) + /* Two built-in candidates; arbitrarily pick one. */ + return 1; + else if (identifier_p (cand1->fn)) + /* cand1 is built-in; prefer cand2. */ + return -1; + else + /* cand2 is built-in; prefer cand1. */ + return 1; + } + } + + /* For candidates of a multi-versioned function, make the version with + the highest priority win. This version will be checked for dispatching + first. If this version can be inlined into the caller, the front-end + will simply make a direct call to this function. */ + + if (TREE_CODE (cand1->fn) == FUNCTION_DECL + && DECL_FUNCTION_VERSIONED (cand1->fn) + && TREE_CODE (cand2->fn) == FUNCTION_DECL + && DECL_FUNCTION_VERSIONED (cand2->fn)) + { + tree f1 = TREE_TYPE (cand1->fn); + tree f2 = TREE_TYPE (cand2->fn); + tree p1 = TYPE_ARG_TYPES (f1); + tree p2 = TYPE_ARG_TYPES (f2); + + /* Check if cand1->fn and cand2->fn are versions of the same function. It + is possible that cand1->fn and cand2->fn are function versions but of + different functions. Check types to see if they are versions of the same + function. */ + if (compparms (p1, p2) + && same_type_p (TREE_TYPE (f1), TREE_TYPE (f2))) + { + /* Always make the version with the higher priority, more + specialized, win. */ + gcc_assert (targetm.compare_version_priority); + if (targetm.compare_version_priority (cand1->fn, cand2->fn) >= 0) + return 1; + else + return -1; + } + } + + /* If the two function declarations represent the same function (this can + happen with declarations in multiple scopes and arg-dependent lookup), + arbitrarily choose one. But first make sure the default args we're + using match. */ + if (DECL_P (cand1->fn) && DECL_P (cand2->fn) + && equal_functions (cand1->fn, cand2->fn)) + { + tree parms1 = TYPE_ARG_TYPES (TREE_TYPE (cand1->fn)); + tree parms2 = TYPE_ARG_TYPES (TREE_TYPE (cand2->fn)); + + gcc_assert (!DECL_CONSTRUCTOR_P (cand1->fn)); + + for (i = 0; i < len; ++i) + { + /* Don't crash if the fn is variadic. */ + if (!parms1) + break; + parms1 = TREE_CHAIN (parms1); + parms2 = TREE_CHAIN (parms2); + } + + if (off1) + parms1 = TREE_CHAIN (parms1); + else if (off2) + parms2 = TREE_CHAIN (parms2); + + for (; parms1; ++i) + { + if (!cp_tree_equal (TREE_PURPOSE (parms1), + TREE_PURPOSE (parms2))) + { + if (warn) + { + if (complain & tf_error) + { + if (permerror (input_location, + "default argument mismatch in " + "overload resolution")) + { + inform (input_location, + " candidate 1: %q+#F", cand1->fn); + inform (input_location, + " candidate 2: %q+#F", cand2->fn); + } + } + else + return 0; + } + else + add_warning (cand1, cand2); + break; + } + parms1 = TREE_CHAIN (parms1); + parms2 = TREE_CHAIN (parms2); + } + + return 1; + } + +tweak: + + /* Extension: If the worst conversion for one candidate is worse than the + worst conversion for the other, take the first. */ + if (!pedantic && (complain & tf_warning_or_error)) + { + conversion_rank rank1 = cr_identity, rank2 = cr_identity; + struct z_candidate *w = 0, *l = 0; + + for (i = 0; i < len; ++i) + { + if (CONVERSION_RANK (cand1->convs[i+off1]) > rank1) + rank1 = CONVERSION_RANK (cand1->convs[i+off1]); + if (CONVERSION_RANK (cand2->convs[i + off2]) > rank2) + rank2 = CONVERSION_RANK (cand2->convs[i + off2]); + } + if (rank1 < rank2) + winner = 1, w = cand1, l = cand2; + if (rank1 > rank2) + winner = -1, w = cand2, l = cand1; + if (winner) + { + /* Don't choose a deleted function over ambiguity. */ + if (DECL_P (w->fn) && DECL_DELETED_FN (w->fn)) + return 0; + if (warn) + { + pedwarn (input_location, 0, + "ISO C++ says that these are ambiguous, even " + "though the worst conversion for the first is better than " + "the worst conversion for the second:"); + print_z_candidate (input_location, _("candidate 1:"), w); + print_z_candidate (input_location, _("candidate 2:"), l); + } + else + add_warning (w, l); + return winner; + } + } + + gcc_assert (!winner); + return 0; +} + +/* Given a list of candidates for overloading, find the best one, if any. + This algorithm has a worst case of O(2n) (winner is last), and a best + case of O(n/2) (totally ambiguous); much better than a sorting + algorithm. */ + +static struct z_candidate * +tourney (struct z_candidate *candidates, tsubst_flags_t complain) +{ + struct z_candidate *champ = candidates, *challenger; + int fate; + int champ_compared_to_predecessor = 0; + + /* Walk through the list once, comparing each current champ to the next + candidate, knocking out a candidate or two with each comparison. */ + + for (challenger = champ->next; challenger; ) + { + fate = joust (champ, challenger, 0, complain); + if (fate == 1) + challenger = challenger->next; + else + { + if (fate == 0) + { + champ = challenger->next; + if (champ == 0) + return NULL; + champ_compared_to_predecessor = 0; + } + else + { + champ = challenger; + champ_compared_to_predecessor = 1; + } + + challenger = champ->next; + } + } + + /* Make sure the champ is better than all the candidates it hasn't yet + been compared to. */ + + for (challenger = candidates; + challenger != champ + && !(champ_compared_to_predecessor && challenger->next == champ); + challenger = challenger->next) + { + fate = joust (champ, challenger, 0, complain); + if (fate != 1) + return NULL; + } + + return champ; +} + +/* Returns nonzero if things of type FROM can be converted to TO. */ + +bool +can_convert (tree to, tree from, tsubst_flags_t complain) +{ + tree arg = NULL_TREE; + /* implicit_conversion only considers user-defined conversions + if it has an expression for the call argument list. */ + if (CLASS_TYPE_P (from) || CLASS_TYPE_P (to)) + arg = build1 (CAST_EXPR, from, NULL_TREE); + return can_convert_arg (to, from, arg, LOOKUP_IMPLICIT, complain); +} + +/* Returns nonzero if things of type FROM can be converted to TO with a + standard conversion. */ + +bool +can_convert_standard (tree to, tree from, tsubst_flags_t complain) +{ + return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT, complain); +} + +/* Returns nonzero if ARG (of type FROM) can be converted to TO. */ + +bool +can_convert_arg (tree to, tree from, tree arg, int flags, + tsubst_flags_t complain) +{ + conversion *t; + void *p; + bool ok_p; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + /* We want to discard any access checks done for this test, + as we might not be in the appropriate access context and + we'll do the check again when we actually perform the + conversion. */ + push_deferring_access_checks (dk_deferred); + + t = implicit_conversion (to, from, arg, /*c_cast_p=*/false, + flags, complain); + ok_p = (t && !t->bad_p); + + /* Discard the access checks now. */ + pop_deferring_access_checks (); + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return ok_p; +} + +/* Like can_convert_arg, but allows dubious conversions as well. */ + +bool +can_convert_arg_bad (tree to, tree from, tree arg, int flags, + tsubst_flags_t complain) +{ + conversion *t; + void *p; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + /* Try to perform the conversion. */ + t = implicit_conversion (to, from, arg, /*c_cast_p=*/false, + flags, complain); + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return t != NULL; +} + +/* Convert EXPR to TYPE. Return the converted expression. + + Note that we allow bad conversions here because by the time we get to + this point we are committed to doing the conversion. If we end up + doing a bad conversion, convert_like will complain. */ + +tree +perform_implicit_conversion_flags (tree type, tree expr, + tsubst_flags_t complain, int flags) +{ + conversion *conv; + void *p; + location_t loc = EXPR_LOC_OR_LOC (expr, input_location); + + if (error_operand_p (expr)) + return error_mark_node; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + conv = implicit_conversion (type, TREE_TYPE (expr), expr, + /*c_cast_p=*/false, + flags, complain); + + if (!conv) + { + if (complain & tf_error) + { + /* If expr has unknown type, then it is an overloaded function. + Call instantiate_type to get good error messages. */ + if (TREE_TYPE (expr) == unknown_type_node) + instantiate_type (type, expr, complain); + else if (invalid_nonstatic_memfn_p (expr, complain)) + /* We gave an error. */; + else + error_at (loc, "could not convert %qE from %qT to %qT", expr, + TREE_TYPE (expr), type); + } + expr = error_mark_node; + } + else if (processing_template_decl && conv->kind != ck_identity) + { + /* In a template, we are only concerned about determining the + type of non-dependent expressions, so we do not have to + perform the actual conversion. But for initializers, we + need to be able to perform it at instantiation + (or fold_non_dependent_expr) time. */ + expr = build1 (IMPLICIT_CONV_EXPR, type, expr); + if (!(flags & LOOKUP_ONLYCONVERTING)) + IMPLICIT_CONV_EXPR_DIRECT_INIT (expr) = true; + } + else + expr = convert_like (conv, expr, complain); + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return expr; +} + +tree +perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain) +{ + return perform_implicit_conversion_flags (type, expr, complain, + LOOKUP_IMPLICIT); +} + +/* Convert EXPR to TYPE (as a direct-initialization) if that is + permitted. If the conversion is valid, the converted expression is + returned. Otherwise, NULL_TREE is returned, except in the case + that TYPE is a class type; in that case, an error is issued. If + C_CAST_P is true, then this direct-initialization is taking + place as part of a static_cast being attempted as part of a C-style + cast. */ + +tree +perform_direct_initialization_if_possible (tree type, + tree expr, + bool c_cast_p, + tsubst_flags_t complain) +{ + conversion *conv; + void *p; + + if (type == error_mark_node || error_operand_p (expr)) + return error_mark_node; + /* [dcl.init] + + If the destination type is a (possibly cv-qualified) class type: + + -- If the initialization is direct-initialization ..., + constructors are considered. ... If no constructor applies, or + the overload resolution is ambiguous, the initialization is + ill-formed. */ + if (CLASS_TYPE_P (type)) + { + vec<tree, va_gc> *args = make_tree_vector_single (expr); + expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, + &args, type, LOOKUP_NORMAL, complain); + release_tree_vector (args); + return build_cplus_new (type, expr, complain); + } + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + conv = implicit_conversion (type, TREE_TYPE (expr), expr, + c_cast_p, + LOOKUP_NORMAL, complain); + if (!conv || conv->bad_p) + expr = NULL_TREE; + else + expr = convert_like_real (conv, expr, NULL_TREE, 0, 0, + /*issue_conversion_warnings=*/false, + c_cast_p, + complain); + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return expr; +} + +/* When initializing a reference that lasts longer than a full-expression, + this special rule applies: + + [class.temporary] + + The temporary to which the reference is bound or the temporary + that is the complete object to which the reference is bound + persists for the lifetime of the reference. + + The temporaries created during the evaluation of the expression + initializing the reference, except the temporary to which the + reference is bound, are destroyed at the end of the + full-expression in which they are created. + + In that case, we store the converted expression into a new + VAR_DECL in a new scope. + + However, we want to be careful not to create temporaries when + they are not required. For example, given: + + struct B {}; + struct D : public B {}; + D f(); + const B& b = f(); + + there is no need to copy the return value from "f"; we can just + extend its lifetime. Similarly, given: + + struct S {}; + struct T { operator S(); }; + T t; + const S& s = t; + + we can extend the lifetime of the return value of the conversion + operator. + + The next several functions are involved in this lifetime extension. */ + +/* DECL is a VAR_DECL or FIELD_DECL whose type is a REFERENCE_TYPE. The + reference is being bound to a temporary. Create and return a new + VAR_DECL with the indicated TYPE; this variable will store the value to + which the reference is bound. */ + +tree +make_temporary_var_for_ref_to_temp (tree decl, tree type) +{ + tree var; + + /* Create the variable. */ + var = create_temporary_var (type); + + /* Register the variable. */ + if (VAR_P (decl) + && (TREE_STATIC (decl) || DECL_THREAD_LOCAL_P (decl))) + { + /* Namespace-scope or local static; give it a mangled name. */ + /* FIXME share comdat with decl? */ + tree name; + + TREE_STATIC (var) = TREE_STATIC (decl); + DECL_TLS_MODEL (var) = DECL_TLS_MODEL (decl); + name = mangle_ref_init_variable (decl); + DECL_NAME (var) = name; + SET_DECL_ASSEMBLER_NAME (var, name); + var = pushdecl_top_level (var); + } + else + /* Create a new cleanup level if necessary. */ + maybe_push_cleanup_level (type); + + return var; +} + +/* EXPR is the initializer for a variable DECL of reference or + std::initializer_list type. Create, push and return a new VAR_DECL + for the initializer so that it will live as long as DECL. Any + cleanup for the new variable is returned through CLEANUP, and the + code to initialize the new variable is returned through INITP. */ + +static tree +set_up_extended_ref_temp (tree decl, tree expr, vec<tree, va_gc> **cleanups, + tree *initp) +{ + tree init; + tree type; + tree var; + + /* Create the temporary variable. */ + type = TREE_TYPE (expr); + var = make_temporary_var_for_ref_to_temp (decl, type); + layout_decl (var, 0); + /* If the rvalue is the result of a function call it will be + a TARGET_EXPR. If it is some other construct (such as a + member access expression where the underlying object is + itself the result of a function call), turn it into a + TARGET_EXPR here. It is important that EXPR be a + TARGET_EXPR below since otherwise the INIT_EXPR will + attempt to make a bitwise copy of EXPR to initialize + VAR. */ + if (TREE_CODE (expr) != TARGET_EXPR) + expr = get_target_expr (expr); + + if (TREE_CODE (decl) == FIELD_DECL + && extra_warnings && !TREE_NO_WARNING (decl)) + { + warning (OPT_Wextra, "a temporary bound to %qD only persists " + "until the constructor exits", decl); + TREE_NO_WARNING (decl) = true; + } + + /* Recursively extend temps in this initializer. */ + TARGET_EXPR_INITIAL (expr) + = extend_ref_init_temps (decl, TARGET_EXPR_INITIAL (expr), cleanups); + + /* Any reference temp has a non-trivial initializer. */ + DECL_NONTRIVIALLY_INITIALIZED_P (var) = true; + + /* If the initializer is constant, put it in DECL_INITIAL so we get + static initialization and use in constant expressions. */ + init = maybe_constant_init (expr); + if (TREE_CONSTANT (init)) + { + if (literal_type_p (type) && CP_TYPE_CONST_NON_VOLATILE_P (type)) + { + /* 5.19 says that a constant expression can include an + lvalue-rvalue conversion applied to "a glvalue of literal type + that refers to a non-volatile temporary object initialized + with a constant expression". Rather than try to communicate + that this VAR_DECL is a temporary, just mark it constexpr. + + Currently this is only useful for initializer_list temporaries, + since reference vars can't appear in constant expressions. */ + DECL_DECLARED_CONSTEXPR_P (var) = true; + DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (var) = true; + TREE_CONSTANT (var) = true; + } + DECL_INITIAL (var) = init; + init = NULL_TREE; + } + else + /* Create the INIT_EXPR that will initialize the temporary + variable. */ + init = build2 (INIT_EXPR, type, var, expr); + if (at_function_scope_p ()) + { + add_decl_expr (var); + + if (TREE_STATIC (var)) + init = add_stmt_to_compound (init, register_dtor_fn (var)); + else + { + tree cleanup = cxx_maybe_build_cleanup (var, tf_warning_or_error); + if (cleanup) + vec_safe_push (*cleanups, cleanup); + } + + /* We must be careful to destroy the temporary only + after its initialization has taken place. If the + initialization throws an exception, then the + destructor should not be run. We cannot simply + transform INIT into something like: + + (INIT, ({ CLEANUP_STMT; })) + + because emit_local_var always treats the + initializer as a full-expression. Thus, the + destructor would run too early; it would run at the + end of initializing the reference variable, rather + than at the end of the block enclosing the + reference variable. + + The solution is to pass back a cleanup expression + which the caller is responsible for attaching to + the statement tree. */ + } + else + { + rest_of_decl_compilation (var, /*toplev=*/1, at_eof); + if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) + { + if (DECL_THREAD_LOCAL_P (var)) + tls_aggregates = tree_cons (NULL_TREE, var, + tls_aggregates); + else + static_aggregates = tree_cons (NULL_TREE, var, + static_aggregates); + } + else + /* Check whether the dtor is callable. */ + cxx_maybe_build_cleanup (var, tf_warning_or_error); + } + + *initp = init; + return var; +} + +/* Convert EXPR to the indicated reference TYPE, in a way suitable for + initializing a variable of that TYPE. */ + +tree +initialize_reference (tree type, tree expr, + int flags, tsubst_flags_t complain) +{ + conversion *conv; + void *p; + location_t loc = EXPR_LOC_OR_LOC (expr, input_location); + + if (type == error_mark_node || error_operand_p (expr)) + return error_mark_node; + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + p = conversion_obstack_alloc (0); + + conv = reference_binding (type, TREE_TYPE (expr), expr, /*c_cast_p=*/false, + flags, complain); + if (!conv || conv->bad_p) + { + if (complain & tf_error) + { + if (conv) + convert_like (conv, expr, complain); + else if (!CP_TYPE_CONST_P (TREE_TYPE (type)) + && !TYPE_REF_IS_RVALUE (type) + && !real_lvalue_p (expr)) + error_at (loc, "invalid initialization of non-const reference of " + "type %qT from an rvalue of type %qT", + type, TREE_TYPE (expr)); + else + error_at (loc, "invalid initialization of reference of type " + "%qT from expression of type %qT", type, + TREE_TYPE (expr)); + } + return error_mark_node; + } + + if (conv->kind == ck_ref_bind) + /* Perform the conversion. */ + expr = convert_like (conv, expr, complain); + else if (conv->kind == ck_ambig) + /* We gave an error in build_user_type_conversion_1. */ + expr = error_mark_node; + else + gcc_unreachable (); + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return expr; +} + +/* Subroutine of extend_ref_init_temps. Possibly extend one initializer, + which is bound either to a reference or a std::initializer_list. */ + +static tree +extend_ref_init_temps_1 (tree decl, tree init, vec<tree, va_gc> **cleanups) +{ + tree sub = init; + tree *p; + STRIP_NOPS (sub); + if (TREE_CODE (sub) == COMPOUND_EXPR) + { + TREE_OPERAND (sub, 1) + = extend_ref_init_temps_1 (decl, TREE_OPERAND (sub, 1), cleanups); + return init; + } + if (TREE_CODE (sub) != ADDR_EXPR) + return init; + /* Deal with binding to a subobject. */ + for (p = &TREE_OPERAND (sub, 0); TREE_CODE (*p) == COMPONENT_REF; ) + p = &TREE_OPERAND (*p, 0); + if (TREE_CODE (*p) == TARGET_EXPR) + { + tree subinit = NULL_TREE; + *p = set_up_extended_ref_temp (decl, *p, cleanups, &subinit); + if (subinit) + init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init); + recompute_tree_invariant_for_addr_expr (sub); + } + return init; +} + +/* INIT is part of the initializer for DECL. If there are any + reference or initializer lists being initialized, extend their + lifetime to match that of DECL. */ + +tree +extend_ref_init_temps (tree decl, tree init, vec<tree, va_gc> **cleanups) +{ + tree type = TREE_TYPE (init); + if (processing_template_decl) + return init; + if (TREE_CODE (type) == REFERENCE_TYPE) + init = extend_ref_init_temps_1 (decl, init, cleanups); + else if (is_std_init_list (type)) + { + /* The temporary array underlying a std::initializer_list + is handled like a reference temporary. */ + tree ctor = init; + if (TREE_CODE (ctor) == TARGET_EXPR) + ctor = TARGET_EXPR_INITIAL (ctor); + if (TREE_CODE (ctor) == CONSTRUCTOR) + { + tree array = CONSTRUCTOR_ELT (ctor, 0)->value; + array = extend_ref_init_temps_1 (decl, array, cleanups); + CONSTRUCTOR_ELT (ctor, 0)->value = array; + } + } + else if (TREE_CODE (init) == CONSTRUCTOR) + { + unsigned i; + constructor_elt *p; + vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init); + FOR_EACH_VEC_SAFE_ELT (elts, i, p) + p->value = extend_ref_init_temps (decl, p->value, cleanups); + } + + return init; +} + +/* Returns true iff an initializer for TYPE could contain temporaries that + need to be extended because they are bound to references or + std::initializer_list. */ + +bool +type_has_extended_temps (tree type) +{ + type = strip_array_types (type); + if (TREE_CODE (type) == REFERENCE_TYPE) + return true; + if (CLASS_TYPE_P (type)) + { + if (is_std_init_list (type)) + return true; + for (tree f = next_initializable_field (TYPE_FIELDS (type)); + f; f = next_initializable_field (DECL_CHAIN (f))) + if (type_has_extended_temps (TREE_TYPE (f))) + return true; + } + return false; +} + +/* Returns true iff TYPE is some variant of std::initializer_list. */ + +bool +is_std_init_list (tree type) +{ + /* Look through typedefs. */ + if (!TYPE_P (type)) + return false; + if (cxx_dialect == cxx98) + return false; + type = TYPE_MAIN_VARIANT (type); + return (CLASS_TYPE_P (type) + && CP_TYPE_CONTEXT (type) == std_node + && strcmp (TYPE_NAME_STRING (type), "initializer_list") == 0); +} + +/* Returns true iff DECL is a list constructor: i.e. a constructor which + will accept an argument list of a single std::initializer_list<T>. */ + +bool +is_list_ctor (tree decl) +{ + tree args = FUNCTION_FIRST_USER_PARMTYPE (decl); + tree arg; + + if (!args || args == void_list_node) + return false; + + arg = non_reference (TREE_VALUE (args)); + if (!is_std_init_list (arg)) + return false; + + args = TREE_CHAIN (args); + + if (args && args != void_list_node && !TREE_PURPOSE (args)) + /* There are more non-defaulted parms. */ + return false; + + return true; +} + +#include "gt-cp-call.h" |