diff options
Diffstat (limited to 'gcc-4.8.1/gcc/cp/call.c')
| -rw-r--r-- | gcc-4.8.1/gcc/cp/call.c | 9349 |
1 files changed, 0 insertions, 9349 deletions
diff --git a/gcc-4.8.1/gcc/cp/call.c b/gcc-4.8.1/gcc/cp/call.c deleted file mode 100644 index 72c1dac25..000000000 --- a/gcc-4.8.1/gcc/cp/call.c +++ /dev/null @@ -1,9349 +0,0 @@ -/* Functions related to invoking methods and overloaded functions. - Copyright (C) 1987-2013 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 "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 bool magic_varargs_p (tree); -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 (TREE_CODE (name) == IDENTIFIER_NODE) - { - 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 < cxx0x) - 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; - - 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 (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->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)) - { - unsigned HOST_WIDE_INT alen = tree_low_cst (array_type_nelts_top (type), 1); - 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) - || 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); - conv = implicit_conversion (to, from, expr, c_cast_p, - flags, complain); - if (!CLASS_TYPE_P (to) - && CONSTRUCTOR_NELTS (expr) == 1) - { - expr = CONSTRUCTOR_ELT (expr, 0)->value; - if (error_operand_p (expr)) - return NULL; - from = TREE_TYPE (expr); - } - } - - 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 to a non-volatile const type. - - Under C++0x, [8.5.3/5 dcl.init.ref] it may also 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; - conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto); - - 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); - - /* 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); - if (TREE_CODE (arg) == CONVERT_EXPR - && TYPE_PTR_P (TREE_TYPE (arg))) - /* Strip conversion from reference to pointer. */ - arg = TREE_OPERAND (arg, 0); - arg = build_fold_indirect_ref (arg); - argtype = lvalue_type (arg); - } - else - parmtype = build_pointer_type (parmtype); - } - - /* 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 (TREE_CODE (type1) == POINTER_TYPE - && !uses_template_parms (TREE_TYPE (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 (TREE_CODE (type1) == POINTER_TYPE) - 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 (TREE_CODE (type1) == POINTER_TYPE - && 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]) - && !uses_template_parms (type1)) - { - type2 = type1; - break; - } - if (null_ptr_cst_p (args[0]) - && TYPE_PTR_P (type2) - && !uses_template_parms (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) - || TREE_CODE (type1) == POINTER_TYPE) - && 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 (); - } - - /* 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); - - 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 - 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 (TREE_CODE (candidate->fn) == IDENTIFIER_NODE) - { - 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 (STRIP_TEMPLATE (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); - 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); - - /* 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 = build_this (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, -1, - 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, -1, - 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_HERE (expr); - - 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) - *size = fold_build3 (COND_EXPR, sizetype, size_check, - original_size, TYPE_MAX_VALUE (sizetype)); - 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 = build_this (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 ((TREE_CODE (totype) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) - || (TREE_CODE (totype) == REFERENCE_TYPE - && TREE_CODE (TREE_TYPE (totype)) == FUNCTION_TYPE) - || (TREE_CODE (totype) == REFERENCE_TYPE - && TREE_CODE (TREE_TYPE (totype)) == POINTER_TYPE - && TREE_CODE (TREE_TYPE (TREE_TYPE (totype))) == FUNCTION_TYPE)) - 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 (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 (input_location, 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); - - 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) - { - if (complain & tf_error) - error ("at least one operand of a vector conditional operator " - "must be a vector"); - return error_mark_node; - } - - if ((TREE_CODE (arg2_type) == VECTOR_TYPE) - != (TREE_CODE (arg3_type) == VECTOR_TYPE)) - { - enum stv_conv convert_flag = - scalar_to_vector (input_location, VEC_COND_EXPR, arg2, arg3, - complain & tf_error); - - switch (convert_flag) - { - case stv_error: - return error_mark_node; - case stv_firstarg: - { - 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 = 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 ("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 = build2 (NE_EXPR, signed_type_for (arg1_type), arg1, - build_zero_cst (arg1_type)); - return 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 ("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 ("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)) - { - error ("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 lvalues and have the same - type, the result is of that type and is an lvalue. */ - if (real_lvalue_p (arg2) - && real_lvalue_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 (input_location, COND_EXPR, NOP_EXPR, - arg1, arg2, arg3, FALSE); - print_z_candidates (location_of (arg1), candidates); - } - return error_mark_node; - } - cand = tourney (candidates, complain); - if (!cand) - { - if (complain & tf_error) - { - op_error (input_location, COND_EXPR, NOP_EXPR, - arg1, arg2, arg3, FALSE); - print_z_candidates (location_of (arg1), 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); - do_warn_double_promotion (result_type, arg2_type, arg3_type, - "implicit conversion from %qT to %qT to " - "match other result of conditional", - input_location); - - 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 (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 (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 ("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); - } - - return result; -} - -/* Wrapper for above. */ - -tree -build_conditional_expr (tree arg1, tree arg2, tree arg3, - tsubst_flags_t complain) -{ - tree ret; - bool subtime = timevar_cond_start (TV_OVERLOAD); - ret = build_conditional_expr_1 (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 (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 = build_this ((*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 (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1)) - && (! arg2 || ! IS_OVERLOAD_TYPE (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 (input_location, 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; - vec_alloc (args, 2); - 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); - vec_free (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, 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 > 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_HERE (expr); - - 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) - && convs->kind != ck_rvalue - && convs->kind != ck_base) - { - 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)) - permerror (loc, "too many braces around initializer for %qT", totype); - - 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; - } - - permerror (loc, "invalid conversion from %qT to %qT", - TREE_TYPE (expr), totype); - if (fn) - permerror (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; - - /* 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); - - /* 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)) - /* Unless we're calling it for value-initialization from an - empty list, since that is handled separately in 8.5.4. */ - && cand->num_convs > 0) - { - error ("converting to %qT from initializer list would use " - "explicit constructor %qD", totype, convfn); - } - - /* 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) - error (" 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); - - /* 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); - return get_target_expr_sfinae (digest_init (totype, expr, complain), - complain); - - 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)); - - error_at (loc, "cannot bind %qT lvalue to %qT", - TREE_TYPE (expr), totype); - if (fn) - error (" 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 && (complain & tf_warning)) - expr = convert_and_check (totype, expr); - else - expr = convert (totype, expr); - - 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_HERE (arg); - - /* [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); - else - 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); - - /* 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); - if (TREE_CODE (arg) == CONSTRUCTOR) - { - arg = digest_init (type, arg, complain); - arg = convert_for_initialization (0, type, arg, LOOKUP_IMPLICIT, - ICR_DEFAULT_ARGUMENT, fn, parmnum, - complain); - } - else - { - 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. */ - -static bool -magic_varargs_p (tree fn) -{ - 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->symbol.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)) - { - if (first_arg != NULL_TREE) - { - argarray[j++] = first_arg; - first_arg = NULL_TREE; - } - else - { - argarray[j++] = (*args)[arg_index]; - ++arg_index; - } - 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 = (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 (TREE_CODE (parmtype) == POINTER_TYPE); - /* 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)) - error ("%qT is not an accessible base of %qT", - BINFO_TYPE (cand->conversion_path), - TREE_TYPE (argtype)); - /* 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) - && !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); - - 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_HERE (fn); - 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; - - /* 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 || TREE_CODE (iface_ref) != VAR_DECL - || 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); - - 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; - tree optype; - tree first_mem_arg = NULL_TREE; - tree instance_ptr; - 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); - 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; - - permerror (input_location, - "cannot call constructor %<%T::%D%> directly", - basetype, name); - permerror (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; - } - - instance_ptr = build_this (instance); - - /* It's OK to call destructors and constructors on cv-qualified objects. - Therefore, convert the INSTANCE_PTR to the unqualified type, if - necessary. */ - if (DECL_DESTRUCTOR_P (fn) - || DECL_CONSTRUCTOR_P (fn)) - { - tree type = build_pointer_type (basetype); - if (!same_type_p (type, TREE_TYPE (instance_ptr))) - instance_ptr = build_nop (type, instance_ptr); - } - if (DECL_DESTRUCTOR_P (fn)) - name = complete_dtor_identifier; - - first_mem_arg = instance_ptr; - - /* 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) - { - tree ob; - if (integer_zerop (instance_ptr)) - return get_target_expr_sfinae (init, complain); - ob = build_fold_indirect_ref (instance_ptr); - init = build2 (INIT_EXPR, TREE_TYPE (ob), ob, 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_ptr, 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 (TREE_TYPE (instance_ptr))); - 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 (TREE_TYPE (instance_ptr))); - 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 - && (DECL_CONSTRUCTOR_P (current_function_decl) - || DECL_DESTRUCTOR_P (current_function_decl)) - && (complain & tf_warning)) - /* This is not an error, it is runtime undefined - behavior. */ - 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_ptr)) - { - 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. */ - instance_ptr = build_this (instance); - cand->first_arg = instance_ptr; - } - 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 instance type 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), TREE_TYPE (instance)) - && 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_ptr) - && TREE_SIDE_EFFECTS (instance_ptr)) - call = build2 (COMPOUND_EXPR, TREE_TYPE (call), - instance_ptr, 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 (TREE_CODE (call) == INDIRECT_REF) - 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 (TREE_CODE (deref_to_type1) == VOID_TYPE - && TREE_CODE (deref_to_type2) == VOID_TYPE) - { - 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 (TREE_CODE (deref_to_type1) == VOID_TYPE - || TREE_CODE (deref_to_type2) == VOID_TYPE) - { - if (same_type_p (deref_from_type1, deref_from_type2)) - { - if (TREE_CODE (deref_to_type2) == VOID_TYPE) - { - 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 (TREE_CODE (cand1->fn) == IDENTIFIER_NODE - || TREE_CODE (cand2->fn) == IDENTIFIER_NODE) - { - 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 (TREE_CODE (cand1->fn) == IDENTIFIER_NODE) - /* 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) - { - 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) -{ - 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_HERE (expr); - - 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 (TREE_CODE (decl) == VAR_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); - } - } - - *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_HERE (expr); - - 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; - } - - gcc_assert (conv->kind == ck_ref_bind); - - /* Perform the conversion. */ - expr = convert_like (conv, expr, complain); - - /* 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; - 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" |