FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR c++/7412 ([DR 106] References to references)

Browse source 
2007-05-30  Russell Yanofsky <russ@yanofsky.org>
            Douglas Gregor <doug.gregor@gmail.com>
            Pedro Lamarao <pedro.lamarao@mndfck.org>
            Howard Hinnant <howard.hinnant@gmail.com>

	PR c++/7412
	PR c++/29939
        * g++.dg/cpp0x/rv8p.C: New.
        * g++.dg/cpp0x/temp-constructor-bug.C: New.
        * g++.dg/cpp0x/cast-bug.C: New.
        * g++.dg/cpp0x/elision_weak.C: New.
        * g++.dg/cpp0x/collapse-bug.C: New.
        * g++.dg/cpp0x/rv3p.C: New.
        * g++.dg/cpp0x/rv7n.C: New.
        * g++.dg/cpp0x/overload-conv-1.C: New.
        * g++.dg/cpp0x/rv2n.C: New.
        * g++.dg/cpp0x/deduce.C: New.
        * g++.dg/cpp0x/temp-va-arg-bug.C: New.
        * g++.dg/cpp0x/rv6p.C: New.
        * g++.dg/cpp0x/template_deduction.C: New.
        * g++.dg/cpp0x/implicit-copy.C: New.
        * g++.dg/cpp0x/rv1p.C: New.
        * g++.dg/cpp0x/cast.C: New.
        * g++.dg/cpp0x/rv5n.C: New.
        * g++.dg/cpp0x/collapse.C: New.
        * g++.dg/cpp0x/overload-conv-2.C: New.
        * g++.dg/cpp0x/rv4p.C: New.
	* g++.dg/cpp0x/rvo.C: New.
        * g++.dg/cpp0x/iop.C: New.
        * g++.dg/cpp0x/rv3n.C: New.
        * g++.dg/cpp0x/rv7p.C: New.
        * g++.dg/cpp0x/reference_collapsing.C: New.
        * g++.dg/cpp0x/overload.C: New.
        * g++.dg/cpp0x/named.C: New.
        * g++.dg/cpp0x/rv2p.C: New.
        * g++.dg/cpp0x/rv6n.C: New.
        * g++.dg/cpp0x/not_special.C: New.
        * g++.dg/cpp0x/bind.C: New.
        * g++.dg/cpp0x/rv1n.C: New.
        * g++.dg/cpp0x/rv5p.C: New.
        * g++.dg/cpp0x/elision.C: New.
        * g++.dg/cpp0x/named_refs.C: New.
        * g++.dg/cpp0x/unnamed_refs.C: New.
        * g++.dg/cpp0x/rv4n.C: New.
        * g++.dg/cpp0x/elision_neg.C: New.
        * g++.dg/init/copy7.C: Run in C++98 mode.
        * g++.dg/overload/arg1.C: Ditto.
        * g++.dg/overload/arg4.C: Ditto.
	
2007-05-30  Russell Yanofsky <russ@yanofsky.org>
            Douglas Gregor <doug.gregor@gmail.com>
            Pedro Lamarao <pedro.lamarao@mndfck.org>
            Howard Hinnant <howard.hinnant@gmail.com>

	PR c++/7412
	PR c++/29939
	* typeck.c (comptypes): Don't consider rvalue and lvalue
	reference types to be equivalent.
	(check_return_expr): Move from certain lvalues when returning
	them.
	* decl.c (grokdeclarator): Implement reference collapsing.
	(copy_fn_p): Don't consider constructors taking rvalue references
	to be copy constructors.
	(move_fn_p): New.
        * call.c (conversion): New "rvaluedness_matches_p" member.
	(convert_class_to_reference): Require reference type as first
	parameter instead of base type.
	(reference_binding): Add logic to handle rvalue references.
	(implicit_conversion): Update inaccurate comment.
	(convert_like_real): Disable creation of temporaries that are
	impossible to initialize for types with move constructors.
	(build_over_call): Elide move constructors when possible.
	(maybe_handle_implicit_object): Set "rvaluedness_matches_p".
	(maybe_handle_ref_bind): Return conversion instead of type node.
	(compare_ics): Add logic to use "rvaluedness_matches_p" values to
	determine preferred conversion sequences.
	* cp-tree.h (TYPE_REF_IS_RVALUE): New.
	(LOOKUP_PREFER_RVALUE): New.
	(DECL_MOVE_CONSTRUCTOR_P): New.
	(struct cp_declarator): Add "reference" member for reference
	types, with new "rvalue_ref" flag.
	(cp_build_reference_type): Declare.
	(move_fn_p): Declare.
	* error.c (dump_type_prefix): Format rvalue reference types
	correctly in error messages.
	* except.c (build_throw): Move from certain lvalues when
	throwing.
	* mangle.c (write_type): Mangle rvalue references differently
	than regular references.
	* parser.c (make_reference_declarator): Add boolean parameter for
	rvalue references.
	(cp_parser_make_indirect_declarator): New.
	(cp_parser_new_declarator_opt): Call
	cp_parser_make_indirect_declarator. 
	(cp_parser_conversion_declarator_opt): Ditto.
	(cp_parser_declarator): Ditto.
	(cp_parser_ptr_operator): Parse "&&" tokens into rvalue reference
	declarators.
	* pt.c (tsubst): Implement reference collapsing.
	(maybe_adjust_types_for_deduction): Implement special template
	parameter deduction rule for rvalue references.
	(type_unification_real): Update calls to
	maybe_adjust_types_for_deduction.
	(try_one_overload): Ditto.
	(unify_pack_expansion): Ditto.
	* tree.c (lvalue_p_1): Handle rvalue reference types.
	(cp_build_reference_type): New.

From-SVN: r125211
This commit is contained in:
Russell Yanofsky 2007-05-31 01:18:22 +00:00 • committed by Doug Gregor
parent 0ae581acf1
commit 8af2fec40b
54 changed files with 10486 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
ChangeLog
View file

@ -457,6 +457,7 @@
install-gcc.
* Makefile.in: Regenerate.
>>>>>>> .merge-right.r70
2006-12-04 Richard Guenther <rguenther@suse.de>
* MAINTAINERS (Non-Algorithmic Maintainers): New section.

59
gcc/cp/ChangeLog
View file

@ -1,3 +1,62 @@
2007-05-30 Russell Yanofsky <russ@yanofsky.org>
Douglas Gregor <doug.gregor@gmail.com>
Pedro Lamarao <pedro.lamarao@mndfck.org>
Howard Hinnant <howard.hinnant@gmail.com>
PR c++/7412
PR c++/29939
* typeck.c (comptypes): Don't consider rvalue and lvalue
reference types to be equivalent.
(check_return_expr): Move from certain lvalues when returning
them.
* decl.c (grokdeclarator): Implement reference collapsing.
(copy_fn_p): Don't consider constructors taking rvalue references
to be copy constructors.
(move_fn_p): New.
* call.c (conversion): New "rvaluedness_matches_p" member.
(convert_class_to_reference): Require reference type as first
parameter instead of base type.
(reference_binding): Add logic to handle rvalue references.
(implicit_conversion): Update inaccurate comment.
(convert_like_real): Disable creation of temporaries that are
impossible to initialize for types with move constructors.
(build_over_call): Elide move constructors when possible.
(maybe_handle_implicit_object): Set "rvaluedness_matches_p".
(maybe_handle_ref_bind): Return conversion instead of type node.
(compare_ics): Add logic to use "rvaluedness_matches_p" values to
determine preferred conversion sequences.
* cp-tree.h (TYPE_REF_IS_RVALUE): New.
(LOOKUP_PREFER_RVALUE): New.
(DECL_MOVE_CONSTRUCTOR_P): New.
(struct cp_declarator): Add "reference" member for reference
types, with new "rvalue_ref" flag.
(cp_build_reference_type): Declare.
(move_fn_p): Declare.
* error.c (dump_type_prefix): Format rvalue reference types
correctly in error messages.
* except.c (build_throw): Move from certain lvalues when
throwing.
* mangle.c (write_type): Mangle rvalue references differently
than regular references.
* parser.c (make_reference_declarator): Add boolean parameter for
rvalue references.
(cp_parser_make_indirect_declarator): New.
(cp_parser_new_declarator_opt): Call
cp_parser_make_indirect_declarator.
(cp_parser_conversion_declarator_opt): Ditto.
(cp_parser_declarator): Ditto.
(cp_parser_ptr_operator): Parse "&&" tokens into rvalue reference
declarators.
* pt.c (tsubst): Implement reference collapsing.
(maybe_adjust_types_for_deduction): Implement special template
parameter deduction rule for rvalue references.
(type_unification_real): Update calls to
maybe_adjust_types_for_deduction.
(try_one_overload): Ditto.
(unify_pack_expansion): Ditto.
* tree.c (lvalue_p_1): Handle rvalue reference types.
(cp_build_reference_type): New.
2007-05-30 Jakub Jelinek <jakub@redhat.com>
PR c++/31809

110
gcc/cp/call.c
View file

@ -97,6 +97,10 @@ struct conversion {
/* 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. */
BOOL_BITFIELD rvaluedness_matches_p: 1;
/* The type of the expression resulting from the conversion. */
tree type;
union {
@ -176,7 +180,7 @@ static conversion *standard_conversion (tree, tree, tree, bool, int);
static conversion *reference_binding (tree, tree, tree, bool, int);
static conversion *build_conv (conversion_kind, tree, conversion *);
static bool is_subseq (conversion *, conversion *);
static tree maybe_handle_ref_bind (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, size_t,
@ -918,12 +922,12 @@ reference_compatible_p (tree t1, tree t2)
converted to T as in [over.match.ref]. */
static conversion *
convert_class_to_reference (tree t, tree s, tree expr)
convert_class_to_reference (tree reference_type, tree s, tree expr)
{
tree conversions;
tree arglist;
conversion *conv;
tree reference_type;
tree t;
struct z_candidate *candidates;
struct z_candidate *cand;
bool any_viable_p;
@ -957,7 +961,7 @@ convert_class_to_reference (tree t, tree s, tree expr)
arglist = build_int_cst (build_pointer_type (s), 0);
arglist = build_tree_list (NULL_TREE, arglist);
reference_type = build_reference_type (t);
t = TREE_TYPE (reference_type);
while (conversions)
{
@ -1020,6 +1024,9 @@ convert_class_to_reference (tree t, tree s, tree expr)
cand->second_conv
= (direct_reference_binding
(reference_type, identity_conv));
cand->second_conv->rvaluedness_matches_p
= TYPE_REF_IS_RVALUE (TREE_TYPE (TREE_TYPE (cand->fn)))
== TYPE_REF_IS_RVALUE (reference_type);
cand->second_conv->bad_p |= cand->convs[0]->bad_p;
}
}
@ -1146,7 +1153,16 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
to = build_qualified_type (to, cp_type_quals (from));
compatible_p = reference_compatible_p (to, from);
if (lvalue_p && compatible_p)
/* Directly bind reference when target expression's type is compatible with
the reference and expression is an lvalue. In C++0x, the wording in
[8.5.3/5 dcl.init.ref] is changed to also allow direct bindings for const
and rvalue references to rvalues of compatible class type, as part of
DR391. */
if (compatible_p
&& (lvalue_p
|| (flag_cpp0x
&& (CP_TYPE_CONST_NON_VOLATILE_P(to) || TYPE_REF_IS_RVALUE (rto))
&& CLASS_TYPE_P (from))))
{
/* [dcl.init.ref]
@ -1159,6 +1175,15 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
lvalue. */
conv = build_identity_conv (from, 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
conv->rvaluedness_matches_p
= (TYPE_REF_IS_RVALUE (rto) == !lvalue_p);
if ((lvalue_p & clk_bitfield) != 0
|| ((lvalue_p & clk_packed) != 0 && !TYPE_PACKED (to)))
/* For the purposes of overload resolution, we ignore the fact
@ -1191,7 +1216,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
the reference is bound to the lvalue result of the conversion
in the second case. */
conv = convert_class_to_reference (to, from, expr);
conv = convert_class_to_reference (rto, from, expr);
if (conv)
return conv;
}
@ -1214,8 +1239,10 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
/* [dcl.init.ref]
Otherwise, the reference shall be to a non-volatile const type. */
if (!CP_TYPE_CONST_NON_VOLATILE_P (to))
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]
@ -1238,6 +1265,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
{
conv = build_identity_conv (from, expr);
conv = direct_reference_binding (rto, conv);
conv->rvaluedness_matches_p = TYPE_REF_IS_RVALUE (rto);
if (!(flags & LOOKUP_CONSTRUCTOR_CALLABLE))
conv->u.next->check_copy_constructor_p = true;
return conv;
@ -1262,6 +1290,7 @@ reference_binding (tree rto, tree rfrom, tree expr, bool c_cast_p, int flags)
/* 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;
}
@ -1303,7 +1332,7 @@ implicit_conversion (tree to, tree from, tree expr, bool c_cast_p,
conv = cand->second_conv;
/* We used to try to bind a reference to a temporary here, but that
is now handled by the recursive call to this function at the end
is now handled after the recursive call to this function at the end
of reference_binding. */
return conv;
}
@ -4448,13 +4477,22 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
{
tree ref_type = totype;
/* If necessary, create a temporary. */
if (convs->need_temporary_p || !lvalue_p (expr))
/* 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 build_unary_op (ADDR_EXPR, expr, ...)
doesn't fail. */
if (convs->need_temporary_p
|| TREE_CODE (expr) == CONSTRUCTOR
|| TREE_CODE (expr) == VA_ARG_EXPR)
{
tree type = convs->u.next->type;
cp_lvalue_kind lvalue = real_lvalue_p (expr);
if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)))
if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type))
&& !TYPE_REF_IS_RVALUE (ref_type))
{
/* If the reference is volatile or non-const, we
cannot create a temporary. */
@ -4963,7 +5001,9 @@ build_over_call (struct z_candidate *cand, int flags)
if (! flag_elide_constructors)
/* Do things the hard way. */;
else if (cand->num_convs == 1 && DECL_COPY_CONSTRUCTOR_P (fn))
else if (cand->num_convs == 1
&& (DECL_COPY_CONSTRUCTOR_P (fn)
|| DECL_MOVE_CONSTRUCTOR_P (fn)))
{
tree targ;
arg = argarray[num_artificial_parms_for (fn)];
@ -5697,28 +5737,28 @@ maybe_handle_implicit_object (conversion **ics)
t = t->u.next;
t = build_identity_conv (TREE_TYPE (t->type), NULL_TREE);
t = direct_reference_binding (reference_type, t);
t->rvaluedness_matches_p = 1;
*ics = t;
}
}
/* If *ICS is a REF_BIND set *ICS to the remainder of the conversion,
and return the type to which the reference refers. Otherwise,
leave *ICS unchanged and return NULL_TREE. */
and return the initial reference binding conversion. Otherwise,
leave *ICS unchanged and return NULL. */
static tree
static conversion *
maybe_handle_ref_bind (conversion **ics)
{
if ((*ics)->kind == ck_ref_bind)
{
conversion *old_ics = *ics;
tree type = TREE_TYPE (old_ics->type);
*ics = old_ics->u.next;
(*ics)->user_conv_p = old_ics->user_conv_p;
(*ics)->bad_p = old_ics->bad_p;
return type;
return old_ics;
}
return NULL_TREE;
return NULL;
}
/* Compare two implicit conversion sequences according to the rules set out in
@ -5742,18 +5782,18 @@ compare_ics (conversion *ics1, conversion *ics2)
conversion_rank rank1, rank2;
/* REF_BINDING is nonzero if the result of the conversion sequence
is a reference type. In that case TARGET_TYPE is the
type referred to by the reference. */
tree target_type1;
tree target_type2;
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. */
target_type1 = maybe_handle_ref_bind (&ics1);
target_type2 = maybe_handle_ref_bind (&ics2);
ref_conv1 = maybe_handle_ref_bind (&ics1);
ref_conv2 = maybe_handle_ref_bind (&ics2);
/* [over.ics.rank]
@ -6044,15 +6084,31 @@ compare_ics (conversion *ics1, conversion *ics2)
/* [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 */
if (target_type1 && target_type2
if (ref_conv1 && ref_conv2
&& same_type_ignoring_top_level_qualifiers_p (to_type1, to_type2))
return comp_cv_qualification (target_type2, target_type1);
{
if (ref_conv1->rvaluedness_matches_p
&& !ref_conv2->rvaluedness_matches_p)
return 1;
else if (!ref_conv1->rvaluedness_matches_p
&& ref_conv2->rvaluedness_matches_p)
return -1;
return comp_cv_qualification (TREE_TYPE (ref_conv2->type),
TREE_TYPE (ref_conv1->type));
}
/* Neither conversion sequence is better than the other. */
return 0;

23
gcc/cp/cp-tree.h
View file

@ -57,6 +57,7 @@ struct diagnostic_context;
BASELINK_QUALIFIED_P (in BASELINK)
TARGET_EXPR_IMPLICIT_P (in TARGET_EXPR)
TEMPLATE_PARM_PARAMETER_PACK (in TEMPLATE_PARM_INDEX)
TYPE_REF_IS_RVALUE (in REFERENCE_TYPE)
1: IDENTIFIER_VIRTUAL_P (in IDENTIFIER_NODE)
TI_PENDING_TEMPLATE_FLAG.
TEMPLATE_PARMS_FOR_INLINE.
@ -1759,6 +1760,10 @@ struct lang_decl GTY(())
#define DECL_COPY_CONSTRUCTOR_P(NODE) \
(DECL_CONSTRUCTOR_P (NODE) && copy_fn_p (NODE) > 0)
/* Nonzero if NODE (a FUNCTION_DECL) is a move constructor. */
#define DECL_MOVE_CONSTRUCTOR_P(NODE) \
(DECL_CONSTRUCTOR_P (NODE) && move_fn_p (NODE))
/* Nonzero if NODE is a destructor. */
#define DECL_DESTRUCTOR_P(NODE) \
(DECL_LANG_SPECIFIC (NODE)->decl_flags.destructor_attr)
@ -2813,6 +2818,10 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
#define TYPE_REF_OBJ_P(NODE) \
(TREE_CODE (NODE) == REFERENCE_TYPE && TYPE_OBJ_P (TREE_TYPE (NODE)))
/* True if reference type NODE is an rvalue reference */
#define TYPE_REF_IS_RVALUE(NODE) \
TREE_LANG_FLAG_0 (REFERENCE_TYPE_CHECK (NODE))
/* Returns true if NODE is a pointer to an object, or a pointer to
void. Keep these checks in ascending tree code order. */
#define TYPE_PTROBV_P(NODE) \
@ -3687,6 +3696,8 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG };
(Normally, these entities are registered in the symbol table, but
not found by lookup.) */
#define LOOKUP_HIDDEN (LOOKUP_CONSTRUCTOR_CALLABLE << 1)
/* Prefer that the lvalue be treated as an rvalue. */
#define LOOKUP_PREFER_RVALUE (LOOKUP_HIDDEN << 1)
#define LOOKUP_NAMESPACES_ONLY(F) \
(((F) & LOOKUP_PREFER_NAMESPACES) && !((F) & LOOKUP_PREFER_TYPES))
@ -4007,13 +4018,21 @@ struct cp_declarator {
/* The bounds to the array. */
tree bounds;
} array;
/* For cdk_pointer, cdk_reference, and cdk_ptrmem. */
/* For cdk_pointer and cdk_ptrmem. */
struct {
/* The cv-qualifiers for the pointer. */
cp_cv_quals qualifiers;
/* For cdk_ptrmem, the class type containing the member. */
tree class_type;
} pointer;
/* For cdk_reference */
struct {
/* The cv-qualifiers for the reference. These qualifiers are
only used to diagnose ill-formed code. */
cp_cv_quals qualifiers;
/* Whether this is an rvalue reference */
bool rvalue_ref;
} reference;
} u;
};
@ -4176,6 +4195,7 @@ extern tree build_ptrmem_type (tree, tree);
/* the grokdeclarator prototype is in decl.h */
extern tree build_this_parm (tree, cp_cv_quals);
extern int copy_fn_p (tree);
extern bool move_fn_p (tree);
extern tree get_scope_of_declarator (const cp_declarator *);
extern void grok_special_member_properties (tree);
extern int grok_ctor_properties (tree, tree);
@ -4684,6 +4704,7 @@ extern int is_dummy_object (tree);
extern const struct attribute_spec cxx_attribute_table[];
extern tree make_ptrmem_cst (tree, tree);
extern tree cp_build_type_attribute_variant (tree, tree);
extern tree cp_build_reference_type (tree, bool);
extern tree cp_build_qualified_type_real (tree, int, tsubst_flags_t);
#define cp_build_qualified_type(TYPE, QUALS) \
cp_build_qualified_type_real ((TYPE), (QUALS), tf_warning_or_error)

107
gcc/cp/decl.c
View file

@ -7794,10 +7794,24 @@ grokdeclarator (const cp_declarator *declarator,
if (TREE_CODE (type) == REFERENCE_TYPE)
{
error (declarator->kind == cdk_reference
? "cannot declare reference to %q#T"
: "cannot declare pointer to %q#T", type);
type = TREE_TYPE (type);
if (declarator->kind != cdk_reference)
{
error ("cannot declare pointer to %q#T", type);
type = TREE_TYPE (type);
}
/* In C++0x, we allow reference to reference declarations
that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
and template type arguments [14.3.1/4 temp.arg.type]. The
check for direct reference to reference declarations, which
are still forbidden, occurs below. Reasoning behind the change
can be found in DR106, DR540, and the rvalue reference
proposals. */
else if (!flag_cpp0x)
{
error ("cannot declare reference to %q#T", type);
type = TREE_TYPE (type);
}
}
else if (VOID_TYPE_P (type))
{
@ -7823,8 +7837,39 @@ grokdeclarator (const cp_declarator *declarator,
if (declarator->kind == cdk_reference)
{
/* In C++0x, the type we are creating a reference to might be
a typedef which is itself a reference type. In that case,
we follow the reference collapsing rules in
[7.1.3/8 dcl.typedef] to create the final reference type:
"If a typedef TD names a type that is a reference to a type
T, an attempt to create the type 'lvalue reference to cv TD'
creates the type 'lvalue reference to T,' while an attempt
to create the type "rvalue reference to cv TD' creates the
type TD."
*/
if (!VOID_TYPE_P (type))
type = build_reference_type (type);
type = cp_build_reference_type
((TREE_CODE (type) == REFERENCE_TYPE
? TREE_TYPE (type) : type),
(declarator->u.reference.rvalue_ref
&& (TREE_CODE(type) != REFERENCE_TYPE
|| TYPE_REF_IS_RVALUE (type))));
/* In C++0x, we need this check for direct reference to
reference declarations, which are forbidden by
[8.3.2/5 dcl.ref]. Reference to reference declarations
are only allowed indirectly through typedefs and template
type arguments. Example:
void foo(int & &); // invalid ref-to-ref decl
typedef int & int_ref;
void foo(int_ref &); // valid ref-to-ref decl
*/
if (inner_declarator && inner_declarator->kind == cdk_reference)
error ("cannot declare reference to %q#T, which is not "
"a typedef or a template type argument", type);
}
else if (TREE_CODE (type) == METHOD_TYPE)
type = build_ptrmemfunc_type (build_pointer_type (type));
@ -9075,6 +9120,7 @@ copy_fn_p (tree d)
result = -1;
}
else if (TREE_CODE (arg_type) == REFERENCE_TYPE
&& !TYPE_REF_IS_RVALUE (arg_type)
&& TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
{
if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
@ -9092,6 +9138,57 @@ copy_fn_p (tree d)
return result;
}
/* D is a constructor or overloaded `operator='.
Let T be the class in which D is declared. Then, this function
returns true when D is a move constructor or move assignment
operator, false otherwise. */
bool
move_fn_p (tree d)
{
tree args;
tree arg_type;
bool result = false;
gcc_assert (DECL_FUNCTION_MEMBER_P (d));
if (!flag_cpp0x)
/* There are no move constructors if we aren't in C++0x mode. */
return false;
if (TREE_CODE (d) == TEMPLATE_DECL
|| (DECL_TEMPLATE_INFO (d)
&& DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
/* Instantiations of template member functions are never copy
functions. Note that member functions of templated classes are
represented as template functions internally, and we must
accept those as copy functions. */
return 0;
args = FUNCTION_FIRST_USER_PARMTYPE (d);
if (!args)
return 0;
arg_type = TREE_VALUE (args);
if (arg_type == error_mark_node)
return 0;
if (TREE_CODE (arg_type) == REFERENCE_TYPE
&& TYPE_REF_IS_RVALUE (arg_type)
&& same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
DECL_CONTEXT (d)))
result = true;
args = TREE_CHAIN (args);
if (args && args != void_list_node && !TREE_PURPOSE (args))
/* There are more non-optional args. */
return false;
return result;
}
/* Remember any special properties of member function DECL. */
void grok_special_member_properties (tree decl)

10
gcc/cp/error.c
View file

@ -542,7 +542,15 @@ dump_type_prefix (tree t, int flags)
pp_cxx_whitespace (cxx_pp);
pp_cxx_left_paren (cxx_pp);
}
pp_character (cxx_pp, "&*"[TREE_CODE (t) == POINTER_TYPE]);
if (TREE_CODE (t) == POINTER_TYPE)
pp_character(cxx_pp, '*');
else if (TREE_CODE (t) == REFERENCE_TYPE)
{
if (TYPE_REF_IS_RVALUE (t))
pp_string (cxx_pp, "&&");
else
pp_character (cxx_pp, '&');
}
pp_base (cxx_pp)->padding = pp_before;
pp_cxx_cv_qualifier_seq (cxx_pp, t);
}

15
gcc/cp/except.c
View file

@ -709,12 +709,25 @@ build_throw (tree exp)
/* And initialize the exception object. */
if (CLASS_TYPE_P (temp_type))
{
int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
/* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes
treated as an rvalue for the purposes of overload resolution
to favor move constructors over copy constructors. */
if (/* Must be a local, automatic variable. */
TREE_CODE (exp) == VAR_DECL
&& DECL_CONTEXT (exp) == current_function_decl
&& ! TREE_STATIC (exp)
/* The variable must not have the `volatile' qualifier. */
&& !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE))
flags = flags | LOOKUP_PREFER_RVALUE;
/* Call the copy constructor. */
exp = (build_special_member_call
(object, complete_ctor_identifier,
build_tree_list (NULL_TREE, exp),
TREE_TYPE (object),
LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING));
flags));
if (exp == error_mark_node)
{
error (" in thrown expression");

6
gcc/cp/mangle.c
View file

@ -1541,6 +1541,10 @@ write_local_name (const tree function, const tree local_entity,
::= G <type> # imaginary (C 2000) [not supported]
::= U <source-name> <type> # vendor extended type qualifier
C++0x extensions
<type> ::= RR <type> # rvalue reference-to
TYPE is a type node. */
static void
@ -1635,6 +1639,8 @@ write_type (tree type)
break;
case REFERENCE_TYPE:
if (TYPE_REF_IS_RVALUE (type))
write_char('R');
write_char ('R');
write_type (TREE_TYPE (type));
break;

98
gcc/cp/parser.c
View file

@ -858,7 +858,7 @@ static cp_declarator *make_array_declarator
static cp_declarator *make_pointer_declarator
(cp_cv_quals, cp_declarator *);
static cp_declarator *make_reference_declarator
(cp_cv_quals, cp_declarator *);
(cp_cv_quals, cp_declarator *, bool);
static cp_parameter_declarator *make_parameter_declarator
(cp_decl_specifier_seq *, cp_declarator *, tree);
static cp_declarator *make_ptrmem_declarator
@ -960,14 +960,15 @@ make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
/* Like make_pointer_declarator -- but for references. */
cp_declarator *
make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
bool rvalue_ref)
{
cp_declarator *declarator;
declarator = make_declarator (cdk_reference);
declarator->declarator = target;
declarator->u.pointer.qualifiers = cv_qualifiers;
declarator->u.pointer.class_type = NULL_TREE;
declarator->u.reference.qualifiers = cv_qualifiers;
declarator->u.reference.rvalue_ref = rvalue_ref;
if (target)
{
declarator->parameter_pack_p = target->parameter_pack_p;
@ -2015,6 +2016,8 @@ static bool cp_parser_is_keyword
(cp_token *, enum rid);
static tree cp_parser_make_typename_type
(cp_parser *, tree, tree);
static cp_declarator * cp_parser_make_indirect_declarator
(enum tree_code, tree, cp_cv_quals, cp_declarator *);
/* Returns nonzero if we are parsing tentatively. */
@ -2689,6 +2692,27 @@ cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
return make_typename_type (scope, id, typename_type, tf_error);
}
/* This is a wrapper around the
make_{pointer,ptrmem,reference}_declarator functions that decides
which one to call based on the CODE and CLASS_TYPE arguments. The
CODE argument should be one of the values returned by
cp_parser_ptr_operator. */
static cp_declarator *
cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
cp_cv_quals cv_qualifiers,
cp_declarator *target)
{
if (code == INDIRECT_REF)
if (class_type == NULL_TREE)
return make_pointer_declarator (cv_qualifiers, target);
else
return make_ptrmem_declarator (cv_qualifiers, class_type, target);
else if (code == ADDR_EXPR && class_type == NULL_TREE)
return make_reference_declarator (cv_qualifiers, target, false);
else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
return make_reference_declarator (cv_qualifiers, target, true);
gcc_unreachable ();
}
/* Create a new C++ parser. */
@ -5532,15 +5556,8 @@ cp_parser_new_declarator_opt (cp_parser* parser)
/* Parse another optional declarator. */
declarator = cp_parser_new_declarator_opt (parser);
/* Create the representation of the declarator. */
if (type)
declarator = make_ptrmem_declarator (cv_quals, type, declarator);
else if (code == INDIRECT_REF)
declarator = make_pointer_declarator (cv_quals, declarator);
else
declarator = make_reference_declarator (cv_quals, declarator);
return declarator;
return cp_parser_make_indirect_declarator
(code, type, cv_quals, declarator);
}
/* If the next token is a `[', there is a direct-new-declarator. */
@ -8460,16 +8477,8 @@ cp_parser_conversion_declarator_opt (cp_parser* parser)
/* Parse another optional declarator. */
declarator = cp_parser_conversion_declarator_opt (parser);
/* Create the representation of the declarator. */
if (class_type)
declarator = make_ptrmem_declarator (cv_quals, class_type,
declarator);
else if (code == INDIRECT_REF)
declarator = make_pointer_declarator (cv_quals, declarator);
else
declarator = make_reference_declarator (cv_quals, declarator);
return declarator;
return cp_parser_make_indirect_declarator
(code, class_type, cv_quals, declarator);
}
return NULL;
@ -12072,15 +12081,8 @@ cp_parser_declarator (cp_parser* parser,
&& !cp_parser_parse_definitely (parser))
declarator = NULL;
/* Build the representation of the ptr-operator. */
if (class_type)
declarator = make_ptrmem_declarator (cv_quals,
class_type,
declarator);
else if (code == INDIRECT_REF)
declarator = make_pointer_declarator (cv_quals, declarator);
else
declarator = make_reference_declarator (cv_quals, declarator);
declarator = cp_parser_make_indirect_declarator
(code, class_type, cv_quals, declarator);
}
/* Everything else is a direct-declarator. */
else
@ -12558,12 +12560,15 @@ cp_parser_direct_declarator (cp_parser* parser,
& cv-qualifier-seq [opt]
Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
Returns ADDR_EXPR if a reference was used. In the case of a
pointer-to-member, *TYPE is filled in with the TYPE containing the
member. *CV_QUALS is filled in with the cv-qualifier-seq, or
TYPE_UNQUALIFIED, if there are no cv-qualifiers. Returns
ERROR_MARK if an error occurred. */
Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
an rvalue reference. In the case of a pointer-to-member, *TYPE is
filled in with the TYPE containing the member. *CV_QUALS is
filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
Note that the tree codes returned by this function have nothing
to do with the types of trees that will be eventually be created
to represent the pointer or reference type being parsed. They are
just constants with suggestive names. */
static enum tree_code
cp_parser_ptr_operator (cp_parser* parser,
tree* type,
@ -12579,13 +12584,18 @@ cp_parser_ptr_operator (cp_parser* parser,
/* Peek at the next token. */
token = cp_lexer_peek_token (parser->lexer);
/* If it's a `*' or `&' we have a pointer or reference. */
if (token->type == CPP_MULT || token->type == CPP_AND)
{
/* Remember which ptr-operator we were processing. */
code = (token->type == CPP_AND ? ADDR_EXPR : INDIRECT_REF);
/* Consume the `*' or `&'. */
/* If it's a `*', `&' or `&&' we have a pointer or reference. */
if (token->type == CPP_MULT)
code = INDIRECT_REF;
else if (token->type == CPP_AND)
code = ADDR_EXPR;
else if (flag_cpp0x && token->type == CPP_AND_AND) /* C++0x only */
code = NON_LVALUE_EXPR;
if (code != ERROR_MARK)
{
/* Consume the `*', `&' or `&&'. */
cp_lexer_consume_token (parser->lexer);
/* A `*' can be followed by a cv-qualifier-seq, and so can a

55
gcc/cp/pt.c
View file

@ -114,7 +114,8 @@ static void tsubst_enum (tree, tree, tree);
static tree add_to_template_args (tree, tree);
static tree add_outermost_template_args (tree, tree);
static bool check_instantiated_args (tree, tree, tsubst_flags_t);
static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
tree);
static int type_unification_real (tree, tree, tree, tree,
int, unification_kind_t, int);
static void note_template_header (int);
@ -8729,8 +8730,13 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
-- Attempting to create a pointer to reference type.
-- Attempting to create a reference to a reference type or
a reference to void. */
if (TREE_CODE (type) == REFERENCE_TYPE
a reference to void.
Core issue 106 says that creating a reference to a reference
during instantiation is no longer a cause for failure. We
only enforce this check in strict C++98 mode. */
if ((TREE_CODE (type) == REFERENCE_TYPE
&& ((!flag_cpp0x && flag_iso) || code != REFERENCE_TYPE))
|| (code == REFERENCE_TYPE && TREE_CODE (type) == VOID_TYPE))
{
static location_t last_loc;
@ -8764,8 +8770,22 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
if (TREE_CODE (type) == METHOD_TYPE)
r = build_ptrmemfunc_type (r);
}
else if (TREE_CODE (type) == REFERENCE_TYPE)
/* In C++0x, during template argument substitution, when there is an
attempt to create a reference to a reference type, reference
collapsing is applied as described in [14.3.1/4 temp.arg.type]:
"If a template-argument for a template-parameter T names a type
that is a reference to a type A, an attempt to create the type
'lvalue reference to cv T' creates the type 'lvalue reference to
A,' while an attempt to create the type type rvalue reference to
cv T' creates the type T"
*/
r = cp_build_reference_type
(TREE_TYPE (type),
TYPE_REF_IS_RVALUE (t) && TYPE_REF_IS_RVALUE (type));
else
r = build_reference_type (type);
r = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
r = cp_build_qualified_type_real (r, TYPE_QUALS (t), complain);
if (r != error_mark_node)
@ -11231,12 +11251,14 @@ fn_type_unification (tree fn,
sections are symmetric. PARM is the type of a function parameter
or the return type of the conversion function. ARG is the type of
the argument passed to the call, or the type of the value
initialized with the result of the conversion function. */
initialized with the result of the conversion function.
ARG_EXPR is the original argument expression, which may be null. */
static int
maybe_adjust_types_for_deduction (unification_kind_t strict,
tree* parm,
tree* arg)
tree* arg,
tree arg_expr)
{
int result = 0;
@ -11290,6 +11312,16 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
*arg = TYPE_MAIN_VARIANT (*arg);
}
/* From C++0x [14.8.2.1/3 temp.deduct.call] (after DR606), "If P is
of the form T&&, where T is a template parameter, and the argument
is an lvalue, T is deduced as A& */
if (TREE_CODE (*parm) == REFERENCE_TYPE
&& TYPE_REF_IS_RVALUE (*parm)
&& TREE_CODE (TREE_TYPE (*parm)) == TEMPLATE_TYPE_PARM
&& cp_type_quals (TREE_TYPE (*parm)) == TYPE_UNQUALIFIED
&& arg_expr && real_lvalue_p (arg_expr))
*arg = build_reference_type (*arg);
/* [temp.deduct.call]
If P is a cv-qualified type, the top level cv-qualifiers
@ -11326,7 +11358,7 @@ type_unification_real (tree tparms,
unification_kind_t strict,
int flags)
{
tree parm, arg;
tree parm, arg, arg_expr;
int i;
int ntparms = TREE_VEC_LENGTH (tparms);
int sub_strict;
@ -11371,6 +11403,7 @@ type_unification_real (tree tparms,
parms = TREE_CHAIN (parms);
arg = TREE_VALUE (args);
args = TREE_CHAIN (args);
arg_expr = NULL;
if (arg == error_mark_node)
return 1;
@ -11419,6 +11452,7 @@ type_unification_real (tree tparms,
return 1;
continue;
}
arg_expr = arg;
arg = unlowered_expr_type (arg);
if (arg == error_mark_node)
return 1;
@ -11428,7 +11462,8 @@ type_unification_real (tree tparms,
int arg_strict = sub_strict;
if (!subr)
arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
arg_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg,
arg_expr);
if (unify (tparms, targs, parm, arg, arg_strict))
return 1;
@ -11678,7 +11713,7 @@ try_one_overload (tree tparms,
else if (addr_p)
arg = build_pointer_type (arg);
sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg);
sub_strict |= maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
/* We don't copy orig_targs for this because if we have already deduced
some template args from previous args, unify would complain when we
@ -12014,7 +12049,7 @@ unify_pack_expansion (tree tparms, tree targs, tree packed_parms,
if (!subr)
arg_strict |=
maybe_adjust_types_for_deduction (strict, &parm, &arg);
maybe_adjust_types_for_deduction (strict, &parm, &arg, NULL);
}
if (!skip_arg_p)

69
gcc/cp/tree.c
View file

@ -64,8 +64,28 @@ lvalue_p_1 (tree ref,
cp_lvalue_kind op1_lvalue_kind = clk_none;
cp_lvalue_kind op2_lvalue_kind = clk_none;
/* Expressions of reference type are sometimes wrapped in
INDIRECT_REFs. INDIRECT_REFs are just internal compiler
representation, not part of the language, so we have to look
through them. */
if (TREE_CODE (ref) == INDIRECT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0)))
== REFERENCE_TYPE)
return lvalue_p_1 (TREE_OPERAND (ref, 0),
treat_class_rvalues_as_lvalues);
if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE)
return clk_ordinary;
{
/* unnamed rvalue references are rvalues */
if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
&& TREE_CODE (ref) != PARM_DECL
&& TREE_CODE (ref) != VAR_DECL
&& TREE_CODE (ref) != COMPONENT_REF)
return clk_none;
/* lvalue references and named rvalue refences are lvalues */
return clk_ordinary;
}
if (ref == current_class_ptr)
return clk_none;
@ -588,6 +608,53 @@ build_cplus_array_type (tree elt_type, tree index_type)
return t;
}
/* Return a reference type node referring to TO_TYPE. If RVAL is
true, return an rvalue reference type, otherwise return an lvalue
reference type. If a type node exists, reuse it, otherwise create
a new one. */
tree
cp_build_reference_type (tree to_type, bool rval)
{
tree lvalue_ref, t;
lvalue_ref = build_reference_type (to_type);
if (!rval)
return lvalue_ref;
/* This code to create rvalue reference types is based on and tied
to the code creating lvalue reference types in the middle-end
functions build_reference_type_for_mode and build_reference_type.
It works by putting the rvalue reference type nodes after the
lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
they will effectively be ignored by the middle end. */
for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
if (TYPE_REF_IS_RVALUE (t))
return t;
t = copy_node (lvalue_ref);
TYPE_REF_IS_RVALUE (t) = true;
TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
TYPE_NEXT_REF_TO (lvalue_ref) = t;
TYPE_MAIN_VARIANT (t) = t;
if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
SET_TYPE_STRUCTURAL_EQUALITY (t);
else if (TYPE_CANONICAL (to_type) != to_type)
TYPE_CANONICAL (t)
= cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
else
TYPE_CANONICAL (t) = t;
layout_type (t);
return t;
}
/* Make a variant of TYPE, qualified with the TYPE_QUALS. Handles
arrays correctly. In particular, if TYPE is an array of T's, and

52
gcc/cp/typeck.c
View file

@ -1026,8 +1026,12 @@ structural_comptypes (tree t1, tree t2, int strict)
return false;
break;
case POINTER_TYPE:
case REFERENCE_TYPE:
if (TYPE_REF_IS_RVALUE (t1) != TYPE_REF_IS_RVALUE (t2))
return false;
/* fall through to checks for pointer types */
case POINTER_TYPE:
if (TYPE_MODE (t1) != TYPE_MODE (t2)
|| TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)
|| !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
@ -6532,6 +6536,7 @@ check_return_expr (tree retval, bool *no_warning)
promotions. */
tree valtype;
int fn_returns_value_p;
bool named_return_value_okay_p;
*no_warning = false;
@ -6680,20 +6685,26 @@ check_return_expr (tree retval, bool *no_warning)
See finish_function and finalize_nrv for the rest of this optimization. */
named_return_value_okay_p =
(retval != NULL_TREE
/* Must be a local, automatic variable. */
&& TREE_CODE (retval) == VAR_DECL
&& DECL_CONTEXT (retval) == current_function_decl
&& ! TREE_STATIC (retval)
&& (DECL_ALIGN (retval)
>= DECL_ALIGN (DECL_RESULT (current_function_decl)))
/* The cv-unqualified type of the returned value must be the
same as the cv-unqualified return type of the
function. */
&& same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
(TYPE_MAIN_VARIANT
(TREE_TYPE (TREE_TYPE (current_function_decl))))));
if (fn_returns_value_p && flag_elide_constructors)
{
if (retval != NULL_TREE
&& (current_function_return_value == NULL_TREE
|| current_function_return_value == retval)
&& TREE_CODE (retval) == VAR_DECL
&& DECL_CONTEXT (retval) == current_function_decl
&& ! TREE_STATIC (retval)
&& (DECL_ALIGN (retval)
>= DECL_ALIGN (DECL_RESULT (current_function_decl)))
&& same_type_p ((TYPE_MAIN_VARIANT
(TREE_TYPE (retval))),
(TYPE_MAIN_VARIANT
(TREE_TYPE (TREE_TYPE (current_function_decl))))))
if (named_return_value_okay_p
&& (current_function_return_value == NULL_TREE
|| current_function_return_value == retval))
current_function_return_value = retval;
else
current_function_return_value = error_mark_node;
@ -6712,18 +6723,29 @@ check_return_expr (tree retval, bool *no_warning)
{
/* The type the function is declared to return. */
tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
/* The functype's return type will have been set to void, if it
was an incomplete type. Just treat this as 'return;' */
if (VOID_TYPE_P (functype))
return error_mark_node;
/* Under C++0x [12.8/16 class.copy], a returned lvalue is sometimes
treated as an rvalue for the purposes of overload resolution to
favor move constructors over copy constructors. */
if (flag_cpp0x
&& named_return_value_okay_p
/* The variable must not have the `volatile' qualifier. */
&& !(cp_type_quals (TREE_TYPE (retval)) & TYPE_QUAL_VOLATILE)
/* The return type must be a class type. */
&& CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
flags = flags | LOOKUP_PREFER_RVALUE;
/* First convert the value to the function's return type, then
to the type of return value's location to handle the
case that functype is smaller than the valtype. */
retval = convert_for_initialization
(NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
"return", NULL_TREE, 0);
(NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0);
retval = convert (valtype, retval);
/* If the conversion failed, treat this just like `return;'. */

49
gcc/testsuite/ChangeLog
View file

@ -1,3 +1,52 @@
2007-05-30 Russell Yanofsky <russ@yanofsky.org>
Douglas Gregor <doug.gregor@gmail.com>
Pedro Lamarao <pedro.lamarao@mndfck.org>
Howard Hinnant <howard.hinnant@gmail.com>
PR c++/7412
PR c++/29939
* g++.dg/cpp0x/rv8p.C: New.
* g++.dg/cpp0x/temp-constructor-bug.C: New.
* g++.dg/cpp0x/cast-bug.C: New.
* g++.dg/cpp0x/elision_weak.C: New.
* g++.dg/cpp0x/collapse-bug.C: New.
* g++.dg/cpp0x/rv3p.C: New.
* g++.dg/cpp0x/rv7n.C: New.
* g++.dg/cpp0x/overload-conv-1.C: New.
* g++.dg/cpp0x/rv2n.C: New.
* g++.dg/cpp0x/deduce.C: New.
* g++.dg/cpp0x/temp-va-arg-bug.C: New.
* g++.dg/cpp0x/rv6p.C: New.
* g++.dg/cpp0x/template_deduction.C: New.
* g++.dg/cpp0x/implicit-copy.C: New.
* g++.dg/cpp0x/rv1p.C: New.
* g++.dg/cpp0x/cast.C: New.
* g++.dg/cpp0x/rv5n.C: New.
* g++.dg/cpp0x/collapse.C: New.
* g++.dg/cpp0x/overload-conv-2.C: New.
* g++.dg/cpp0x/rv4p.C: New.
* g++.dg/cpp0x/rvo.C: New.
* g++.dg/cpp0x/iop.C: New.
* g++.dg/cpp0x/rv3n.C: New.
* g++.dg/cpp0x/rv7p.C: New.
* g++.dg/cpp0x/reference_collapsing.C: New.
* g++.dg/cpp0x/overload.C: New.
* g++.dg/cpp0x/named.C: New.
* g++.dg/cpp0x/rv2p.C: New.
* g++.dg/cpp0x/rv6n.C: New.
* g++.dg/cpp0x/not_special.C: New.
* g++.dg/cpp0x/bind.C: New.
* g++.dg/cpp0x/rv1n.C: New.
* g++.dg/cpp0x/rv5p.C: New.
* g++.dg/cpp0x/elision.C: New.
* g++.dg/cpp0x/named_refs.C: New.
* g++.dg/cpp0x/unnamed_refs.C: New.
* g++.dg/cpp0x/rv4n.C: New.
* g++.dg/cpp0x/elision_neg.C: New.
* g++.dg/init/copy7.C: Run in C++98 mode.
* g++.dg/overload/arg1.C: Ditto.
* g++.dg/overload/arg4.C: Ditto.
2007-05-30 Jakub Jelinek <jakub@redhat.com>
PR c++/31809

8
gcc/testsuite/g++.dg/cpp0x/bind.C Normal file
View file

@ -0,0 +1,8 @@
// { dg-options "--std=c++0x" }
struct S{};
void f(S&&);
int main()
{
f(S());
}

14
gcc/testsuite/g++.dg/cpp0x/cast-bug.C Normal file
View file

@ -0,0 +1,14 @@
// { dg-options "--std=c++0x" }
struct S
{
S();
S(S &&);
private:
S(S &);
};
S f()
{
S s;
return static_cast<S&&>(s);
}

30
gcc/testsuite/g++.dg/cpp0x/cast.C Normal file
View file

@ -0,0 +1,30 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test cast from lvalue to rvalue
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct A {};
one foo(const A&) {return one();}
two foo(A&&) {return two();}
int test1()
{
A a;
sa<sizeof(foo(a)) == 1> t1;
sa<sizeof(foo(static_cast<A&&>(a))) == 2> t2;
return 0;
}
int main()
{
return test1();
}

16
gcc/testsuite/g++.dg/cpp0x/collapse-bug.C Normal file
View file

@ -0,0 +1,16 @@
// { dg-options "--std=c++0x" }
template<typename T, typename U> struct same_type;
template<typename T> struct same_type<T, T> {};
template <typename T>
struct S
{
typedef T const (&type)();
};
void f()
{
// initial implementation didn't ignore const qualifier on
// reference, resulting in a typedef of 'const int& (&)()'
same_type<S<int &>::type, int&(&)()>();
}

38
gcc/testsuite/g++.dg/cpp0x/collapse.C Normal file
View file

@ -0,0 +1,38 @@
// { dg-options "--std=c++0x" }
template<typename T, typename U> struct same_type;
template<typename T> struct same_type<T, T> {};
typedef int & lref;
typedef int const & clref;
typedef int && rref;
typedef int const && crref;
template<typename T>
struct S
{
typedef T & lref;
typedef T const & clref;
typedef T && rref;
typedef T const && crref;
};
void f()
{
same_type<lref &, int &>();
same_type<lref &&, int &>();
same_type<rref &, int &>();
same_type<rref &&, int &&>();
same_type<rref const &, int &>();
same_type<crref volatile &&, int const &&>();
same_type<clref const &&, int const &>();
same_type<S<int &>::lref &, int &>();
same_type<S<int &&>::lref &&, int &>();
same_type<S<int &>::rref &, int &>();
same_type<S<int &&>::rref &&, int &&>();
same_type<S<int const &>::rref, int const &>();
same_type<S<int volatile &&>::crref, int volatile &&>();
same_type<S<int const &&>::clref, int const &>();
}

36
gcc/testsuite/g++.dg/cpp0x/deduce.C Normal file
View file

@ -0,0 +1,36 @@
// { dg-options "--std=c++0x" }
template<typename T, typename U> struct same_type;
template<typename T> struct same_type<T, T> {};
int lval_int;
int rval_int();
int const lval_const_int=0;
int const rval_const_int();
template <typename T> void deduce_lval_int(T && t)
{
same_type<T, int &>();
}
template <typename T> void deduce_rval_int(T && t)
{
same_type<T, int>();
}
template <typename T> void deduce_lval_const_int(T && t)
{
same_type<T, const int &>();
}
template <typename T> void deduce_rval_const_int(T && t)
{
same_type<T, const int>();
}
void f()
{
deduce_lval_int(lval_int);
deduce_rval_int(rval_int());
deduce_lval_const_int(lval_const_int);
deduce_rval_const_int(rval_const_int());
}

76
gcc/testsuite/g++.dg/cpp0x/elision.C Normal file
View file

@ -0,0 +1,76 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test: Implicit cast to rvalue when eliding copy
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
class move_only
{
move_only(const move_only&);
move_only& operator=(const move_only&);
public:
move_only() {}
move_only(move_only&&) {}
move_only& operator=(move_only&&) {return *this;}
};
move_only
test1()
{
return move_only();
}
move_only
test2()
{
move_only x;
return x;
}
move_only
test3(bool b)
{
move_only x1;
if (b)
{
move_only x2;
return x2;
}
return x1;
}
void
test4(bool b)
{
if (!b)
throw move_only();
}
void
test5(bool b)
{
move_only x;
if (!b)
throw x;
}
extern bool b;
int main()
{
move_only t1 = test1();
move_only t2 = test2();
move_only t3 = test3(b);
test4(b);
test5(b);
return 0;
}
bool b = true;

44
gcc/testsuite/g++.dg/cpp0x/elision_neg.C Normal file
View file

@ -0,0 +1,44 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test: Implicit cast to rvalue when eliding copy
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
class move_only
{
move_only(const move_only&); // { dg-error "is private" }
move_only& operator=(const move_only&);
public:
move_only() {}
move_only(move_only&&) {}
move_only& operator=(move_only&&) {return *this;}
};
move_only
test1()
{
static move_only x;
return x; // { dg-error "within this context" }
}
move_only
test2(move_only&& x)
{
return x; // { dg-error "within this context" }
}
int main()
{
move_only t1 = test1();
move_only t2 = test2(move_only());
return 0;
}
bool b = true;

19
gcc/testsuite/g++.dg/cpp0x/elision_weak.C Normal file
View file

@ -0,0 +1,19 @@
// { dg-do compile }
struct S
{
S() {}
S(S&) {}
};
S f()
{
S s;
return s;
}
void g()
{
S s;
throw s;
}

15
gcc/testsuite/g++.dg/cpp0x/implicit-copy.C Normal file
View file

@ -0,0 +1,15 @@
// { dg-options "--std=c++0x" }
struct S
{
S();
private:
S(S const &&);
S & operator=(S const &&);
};
void f()
{
S a;
S b(a);
a = b;
}

41
gcc/testsuite/g++.dg/cpp0x/iop.C Normal file
View file

@ -0,0 +1,41 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test that the implicit object parameter is *not* an rvalue reference, but is instead
// identical to that specified in C++03. That is, the implicit object parameter is
// an lvalue reference that can bind to an rvalue. :-\
// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html under the
// section "Revision 1 Summary and Rationale" for more details.
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct os
{
one operator<<(int);
};
struct A
{
A(int);
};
two operator<<(os&, const A&);
void test()
{
os o;
sa<sizeof(o << 1) == 1> t1; // Calls os::operator<<(int)
// Would be ambiguous if the implicit object parameter
// was an rvalue reference.
}
int main()
{
return 0;
}

35
gcc/testsuite/g++.dg/cpp0x/named.C Normal file
View file

@ -0,0 +1,35 @@
// { dg-options "--std=c++0x" }
// { dg-do link }
struct S {};
struct T
{
T(S && s_) : s(s_) {}
S && get() { return s; }
operator S&&() { return s; }
S && s;
};
void named(S const &) {}
void named(S&&);
void unnamed(S const &);
void unnamed(S&&) {}
void f(S && p)
{
S && s(p);
T t(s);
named(s); // variable reference
named(p); // parameter reference
named(t.s); // class member access
unnamed(t.get()); // function return
unnamed(t); // implicit conversion
unnamed(static_cast<S&&>(s)); // cast to rvalue
}
int main()
{
}

28
gcc/testsuite/g++.dg/cpp0x/named_refs.C Normal file
View file

@ -0,0 +1,28 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test: Named rvalue references are treated as lvalues.
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct A {};
one foo(const A&) {return one();}
two foo(A&&) {return two();}
int test1(A&& a)
{
sa<sizeof(foo(a)) == 1> t1;
return 0;
}
int main()
{
return test1(A());
}

54
gcc/testsuite/g++.dg/cpp0x/not_special.C Normal file
View file

@ -0,0 +1,54 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test that move constructor and move assignement are not special.
// That is, their presence should not inhibit compiler generated
// copy ctor or assignment. Rather they should overload with the
// compiler generated special members.
// { dg-do run }
// { dg-options "-std=c++0x" }
#include <assert.h>
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
int copy = 0;
int assign = 0;
struct base
{
base() {}
base(const base&) {++copy;}
base& operator=(const base&) {++assign; return *this;}
};
struct derived
: base
{
derived() {}
derived(derived&&) {}
derived& operator=(derived&&) {return *this;}
};
int test1()
{
derived d;
derived d2(static_cast<derived&&>(d)); // should not call base::(const base&)
assert(copy == 0);
derived d3(d); // should call base::(const base&)
assert(copy == 1);
d2 = static_cast<derived&&>(d); // should not call base::operator=
assert(assign == 0);
d3 = d; // should call base::operator=
assert(assign == 1);
return 0;
}
int main()
{
return test1();
}

29
gcc/testsuite/g++.dg/cpp0x/overload-conv-1.C Normal file
View file

@ -0,0 +1,29 @@
// { dg-options "--std=c++0x" }
// { dg-do link }
struct S {};
struct T
{
operator S() { return S(); }
};
struct U
{
operator S&() { return *static_cast<S*>(0); }
};
void f(const S&);
void f(S&&) {}
void g(const S&) {}
void g(S&&);
int main()
{
T t;
f(t);
U u;
g(u);
}

17
gcc/testsuite/g++.dg/cpp0x/overload-conv-2.C Normal file
View file

@ -0,0 +1,17 @@
// { dg-options "--std=c++0x" }
// { dg-do link }
struct T {};
struct S
{
S(T const &) {}
};
void f(const S&);
void f(S&&) {}
int main()
{
T t;
f(t);
}

703
gcc/testsuite/g++.dg/cpp0x/overload.C Normal file
View file

@ -0,0 +1,703 @@
// { dg-options "--std=c++0x" }
// { dg-do link }
// Generated by overload.py
struct S{};
S l; // lvalue (l)
S const cl = l; // const lvalue (cl)
S r() { return l; } // rvalue (r)
S const cr() { return l; } // const rvalue (cr)
S & nl = l; // named lvalue reference (nl)
S const & ncl = l; // named const lvalue reference (ncl)
S && nr = l; // named rvalue reference (nr)
S const && ncr = l; // named const rvalue reference (ncr)
S & ul() { return l; } // unnamed lvalue reference (ul)
S const & ucl() { return l; } // unnamed const lvalue reference (ucl)
S && ur() { return l; } // unnamed rvalue reference (ur)
S const && ucr() { return l; } // unnamed const rvalue reference (ucr)
void l0001(const S&&) {}
void l0010(S&&) {}
void l0011(S&&) {}
void l0011(const S&&);
void l0100(const S&) {}
void l0101(const S&) {}
void l0101(const S&&);
void l0110(const S&) {}
void l0110(S&&);
void l0111(const S&) {}
void l0111(S&&);
void l0111(const S&&);
void l1000(S&) {}
void l1001(S&) {}
void l1001(const S&&);
void l1010(S&) {}
void l1010(S&&);
void l1011(S&) {}
void l1011(S&&);
void l1011(const S&&);
void l1100(S&) {}
void l1100(const S&);
void l1101(S&) {}
void l1101(const S&);
void l1101(const S&&);
void l1110(S&) {}
void l1110(const S&);
void l1110(S&&);
void l1111(S&) {}
void l1111(const S&);
void l1111(S&&);
void l1111(const S&&);
void cl0001(const S&&) {}
void cl0011(S&&);
void cl0011(const S&&) {}
void cl0100(const S&) {}
void cl0101(const S&) {}
void cl0101(const S&&);
void cl0110(const S&) {}
void cl0110(S&&);
void cl0111(const S&) {}
void cl0111(S&&);
void cl0111(const S&&);
void cl1001(S&);
void cl1001(const S&&) {}
void cl1011(S&);
void cl1011(S&&);
void cl1011(const S&&) {}
void cl1100(S&);
void cl1100(const S&) {}
void cl1101(S&);
void cl1101(const S&) {}
void cl1101(const S&&);
void cl1110(S&);
void cl1110(const S&) {}
void cl1110(S&&);
void cl1111(S&);
void cl1111(const S&) {}
void cl1111(S&&);
void cl1111(const S&&);
void r0001(const S&&) {}
void r0010(S&&) {}
void r0011(S&&) {}
void r0011(const S&&);
void r0100(const S&) {}
void r0101(const S&);
void r0101(const S&&) {}
void r0110(const S&);
void r0110(S&&) {}
void r0111(const S&);
void r0111(S&&) {}
void r0111(const S&&);
void r1001(S&);
void r1001(const S&&) {}
void r1010(S&);
void r1010(S&&) {}
void r1011(S&);
void r1011(S&&) {}
void r1011(const S&&);
void r1100(S&);
void r1100(const S&) {}
void r1101(S&);
void r1101(const S&);
void r1101(const S&&) {}
void r1110(S&);
void r1110(const S&);
void r1110(S&&) {}
void r1111(S&);
void r1111(const S&);
void r1111(S&&) {}
void r1111(const S&&);
void cr0001(const S&&) {}
void cr0011(S&&);
void cr0011(const S&&) {}
void cr0100(const S&) {}
void cr0101(const S&);
void cr0101(const S&&) {}
void cr0110(const S&) {}
void cr0110(S&&);
void cr0111(const S&);
void cr0111(S&&);
void cr0111(const S&&) {}
void cr1001(S&);
void cr1001(const S&&) {}
void cr1011(S&);
void cr1011(S&&);
void cr1011(const S&&) {}
void cr1100(S&);
void cr1100(const S&) {}
void cr1101(S&);
void cr1101(const S&);
void cr1101(const S&&) {}
void cr1110(S&);
void cr1110(const S&) {}
void cr1110(S&&);
void cr1111(S&);
void cr1111(const S&);
void cr1111(S&&);
void cr1111(const S&&) {}
void nl0001(const S&&) {}
void nl0010(S&&) {}
void nl0011(S&&) {}
void nl0011(const S&&);
void nl0100(const S&) {}
void nl0101(const S&) {}
void nl0101(const S&&);
void nl0110(const S&) {}
void nl0110(S&&);
void nl0111(const S&) {}
void nl0111(S&&);
void nl0111(const S&&);
void nl1000(S&) {}
void nl1001(S&) {}
void nl1001(const S&&);
void nl1010(S&) {}
void nl1010(S&&);
void nl1011(S&) {}
void nl1011(S&&);
void nl1011(const S&&);
void nl1100(S&) {}
void nl1100(const S&);
void nl1101(S&) {}
void nl1101(const S&);
void nl1101(const S&&);
void nl1110(S&) {}
void nl1110(const S&);
void nl1110(S&&);
void nl1111(S&) {}
void nl1111(const S&);
void nl1111(S&&);
void nl1111(const S&&);
void ncl0001(const S&&) {}
void ncl0011(S&&);
void ncl0011(const S&&) {}
void ncl0100(const S&) {}
void ncl0101(const S&) {}
void ncl0101(const S&&);
void ncl0110(const S&) {}
void ncl0110(S&&);
void ncl0111(const S&) {}
void ncl0111(S&&);
void ncl0111(const S&&);
void ncl1001(S&);
void ncl1001(const S&&) {}
void ncl1011(S&);
void ncl1011(S&&);
void ncl1011(const S&&) {}
void ncl1100(S&);
void ncl1100(const S&) {}
void ncl1101(S&);
void ncl1101(const S&) {}
void ncl1101(const S&&);
void ncl1110(S&);
void ncl1110(const S&) {}
void ncl1110(S&&);
void ncl1111(S&);
void ncl1111(const S&) {}
void ncl1111(S&&);
void ncl1111(const S&&);
void nr0001(const S&&) {}
void nr0010(S&&) {}
void nr0011(S&&) {}
void nr0011(const S&&);
void nr0100(const S&) {}
void nr0101(const S&) {}
void nr0101(const S&&);
void nr0110(const S&) {}
void nr0110(S&&);
void nr0111(const S&) {}
void nr0111(S&&);
void nr0111(const S&&);
void nr1000(S&) {}
void nr1001(S&) {}
void nr1001(const S&&);
void nr1010(S&) {}
void nr1010(S&&);
void nr1011(S&) {}
void nr1011(S&&);
void nr1011(const S&&);
void nr1100(S&) {}
void nr1100(const S&);
void nr1101(S&) {}
void nr1101(const S&);
void nr1101(const S&&);
void nr1110(S&) {}
void nr1110(const S&);
void nr1110(S&&);
void nr1111(S&) {}
void nr1111(const S&);
void nr1111(S&&);
void nr1111(const S&&);
void ncr0001(const S&&) {}
void ncr0011(S&&);
void ncr0011(const S&&) {}
void ncr0100(const S&) {}
void ncr0101(const S&) {}
void ncr0101(const S&&);
void ncr0110(const S&) {}
void ncr0110(S&&);
void ncr0111(const S&) {}
void ncr0111(S&&);
void ncr0111(const S&&);
void ncr1001(S&);
void ncr1001(const S&&) {}
void ncr1011(S&);
void ncr1011(S&&);
void ncr1011(const S&&) {}
void ncr1100(S&);
void ncr1100(const S&) {}
void ncr1101(S&);
void ncr1101(const S&) {}
void ncr1101(const S&&);
void ncr1110(S&);
void ncr1110(const S&) {}
void ncr1110(S&&);
void ncr1111(S&);
void ncr1111(const S&) {}
void ncr1111(S&&);
void ncr1111(const S&&);
void ul0001(const S&&) {}
void ul0010(S&&) {}
void ul0011(S&&) {}
void ul0011(const S&&);
void ul0100(const S&) {}
void ul0101(const S&) {}
void ul0101(const S&&);
void ul0110(const S&) {}
void ul0110(S&&);
void ul0111(const S&) {}
void ul0111(S&&);
void ul0111(const S&&);
void ul1000(S&) {}
void ul1001(S&) {}
void ul1001(const S&&);
void ul1010(S&) {}
void ul1010(S&&);
void ul1011(S&) {}
void ul1011(S&&);
void ul1011(const S&&);
void ul1100(S&) {}
void ul1100(const S&);
void ul1101(S&) {}
void ul1101(const S&);
void ul1101(const S&&);
void ul1110(S&) {}
void ul1110(const S&);
void ul1110(S&&);
void ul1111(S&) {}
void ul1111(const S&);
void ul1111(S&&);
void ul1111(const S&&);
void ucl0001(const S&&) {}
void ucl0011(S&&);
void ucl0011(const S&&) {}
void ucl0100(const S&) {}
void ucl0101(const S&) {}
void ucl0101(const S&&);
void ucl0110(const S&) {}
void ucl0110(S&&);
void ucl0111(const S&) {}
void ucl0111(S&&);
void ucl0111(const S&&);
void ucl1001(S&);
void ucl1001(const S&&) {}
void ucl1011(S&);
void ucl1011(S&&);
void ucl1011(const S&&) {}
void ucl1100(S&);
void ucl1100(const S&) {}
void ucl1101(S&);
void ucl1101(const S&) {}
void ucl1101(const S&&);
void ucl1110(S&);
void ucl1110(const S&) {}
void ucl1110(S&&);
void ucl1111(S&);
void ucl1111(const S&) {}
void ucl1111(S&&);
void ucl1111(const S&&);
void ur0001(const S&&) {}
void ur0010(S&&) {}
void ur0011(S&&) {}
void ur0011(const S&&);
void ur0100(const S&) {}
void ur0101(const S&);
void ur0101(const S&&) {}
void ur0110(const S&);
void ur0110(S&&) {}
void ur0111(const S&);
void ur0111(S&&) {}
void ur0111(const S&&);
void ur1001(S&);
void ur1001(const S&&) {}
void ur1010(S&);
void ur1010(S&&) {}
void ur1011(S&);
void ur1011(S&&) {}
void ur1011(const S&&);
void ur1100(S&);
void ur1100(const S&) {}
void ur1101(S&);
void ur1101(const S&);
void ur1101(const S&&) {}
void ur1110(S&);
void ur1110(const S&);
void ur1110(S&&) {}
void ur1111(S&);
void ur1111(const S&);
void ur1111(S&&) {}
void ur1111(const S&&);
void ucr0001(const S&&) {}
void ucr0011(S&&);
void ucr0011(const S&&) {}
void ucr0100(const S&) {}
void ucr0101(const S&);
void ucr0101(const S&&) {}
void ucr0110(const S&) {}
void ucr0110(S&&);
void ucr0111(const S&);
void ucr0111(S&&);
void ucr0111(const S&&) {}
void ucr1001(S&);
void ucr1001(const S&&) {}
void ucr1011(S&);
void ucr1011(S&&);
void ucr1011(const S&&) {}
void ucr1100(S&);
void ucr1100(const S&) {}
void ucr1101(S&);
void ucr1101(const S&);
void ucr1101(const S&&) {}
void ucr1110(S&);
void ucr1110(const S&) {}
void ucr1110(S&&);
void ucr1111(S&);
void ucr1111(const S&);
void ucr1111(S&&);
void ucr1111(const S&&) {}
int main()
{
l0001(l);
l0010(l);
l0011(l);
l0100(l);
l0101(l);
l0110(l);
l0111(l);
l1000(l);
l1001(l);
l1010(l);
l1011(l);
l1100(l);
l1101(l);
l1110(l);
l1111(l);
cl0001(cl);
cl0011(cl);
cl0100(cl);
cl0101(cl);
cl0110(cl);
cl0111(cl);
cl1001(cl);
cl1011(cl);
cl1100(cl);
cl1101(cl);
cl1110(cl);
cl1111(cl);
r0001(r());
r0010(r());
r0011(r());
r0100(r());
r0101(r());
r0110(r());
r0111(r());
r1001(r());
r1010(r());
r1011(r());
r1100(r());
r1101(r());
r1110(r());
r1111(r());
cr0001(cr());
cr0011(cr());
cr0100(cr());
cr0101(cr());
cr0110(cr());
cr0111(cr());
cr1001(cr());
cr1011(cr());
cr1100(cr());
cr1101(cr());
cr1110(cr());
cr1111(cr());
nl0001(nl);
nl0010(nl);
nl0011(nl);
nl0100(nl);
nl0101(nl);
nl0110(nl);
nl0111(nl);
nl1000(nl);
nl1001(nl);
nl1010(nl);
nl1011(nl);
nl1100(nl);
nl1101(nl);
nl1110(nl);
nl1111(nl);
ncl0001(ncl);
ncl0011(ncl);
ncl0100(ncl);
ncl0101(ncl);
ncl0110(ncl);
ncl0111(ncl);
ncl1001(ncl);
ncl1011(ncl);
ncl1100(ncl);
ncl1101(ncl);
ncl1110(ncl);
ncl1111(ncl);
nr0001(nr);
nr0010(nr);
nr0011(nr);
nr0100(nr);
nr0101(nr);
nr0110(nr);
nr0111(nr);
nr1000(nr);
nr1001(nr);
nr1010(nr);
nr1011(nr);
nr1100(nr);
nr1101(nr);
nr1110(nr);
nr1111(nr);
ncr0001(ncr);
ncr0011(ncr);
ncr0100(ncr);
ncr0101(ncr);
ncr0110(ncr);
ncr0111(ncr);
ncr1001(ncr);
ncr1011(ncr);
ncr1100(ncr);
ncr1101(ncr);
ncr1110(ncr);
ncr1111(ncr);
ul0001(ul());
ul0010(ul());
ul0011(ul());
ul0100(ul());
ul0101(ul());
ul0110(ul());
ul0111(ul());
ul1000(ul());
ul1001(ul());
ul1010(ul());
ul1011(ul());
ul1100(ul());
ul1101(ul());
ul1110(ul());
ul1111(ul());
ucl0001(ucl());
ucl0011(ucl());
ucl0100(ucl());
ucl0101(ucl());
ucl0110(ucl());
ucl0111(ucl());
ucl1001(ucl());
ucl1011(ucl());
ucl1100(ucl());
ucl1101(ucl());
ucl1110(ucl());
ucl1111(ucl());
ur0001(ur());
ur0010(ur());
ur0011(ur());
ur0100(ur());
ur0101(ur());
ur0110(ur());
ur0111(ur());
ur1001(ur());
ur1010(ur());
ur1011(ur());
ur1100(ur());
ur1101(ur());
ur1110(ur());
ur1111(ur());
ucr0001(ucr());
ucr0011(ucr());
ucr0100(ucr());
ucr0101(ucr());
ucr0110(ucr());
ucr0111(ucr());
ucr1001(ucr());
ucr1011(ucr());
ucr1100(ucr());
ucr1101(ucr());
ucr1110(ucr());
ucr1111(ucr());
return 0;
}

175
gcc/testsuite/g++.dg/cpp0x/reference_collapsing.C Normal file
View file

@ -0,0 +1,175 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test the reference collapsing rules. Note that there are recent differences
// for how cv-qualifications are applied to reference types. 7.1.3, 14.3.1
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
template <class T, T v>
struct integral_constant
{
static const T value = v;
typedef T value_type;
typedef integral_constant<T, v> type;
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template <class T> struct is_lvalue_reference : public integral_constant<bool, false> {};
template <class T> struct is_lvalue_reference<T&> : public integral_constant<bool, true> {};
template <class T> struct is_rvalue_reference : public integral_constant<bool, false> {};
template <class T> struct is_rvalue_reference<T&&> : public integral_constant<bool, true> {};
template <class T> struct remove_reference {typedef T type;};
template <class T> struct remove_reference<T&> {typedef T type;};
template <class T> struct remove_reference<T&&> {typedef T type;};
template <class T> struct is_const : public integral_constant<bool, false> {};
template <class T> struct is_const<T const> : public integral_constant<bool, true> {};
template <class T> struct is_volatile : public integral_constant<bool, false> {};
template <class T> struct is_volatile<T volatile> : public integral_constant<bool, true> {};
struct A {};
typedef A& Alref;
typedef const A& cAlref;
typedef volatile A& vAlref;
typedef const volatile A& cvAlref;
typedef A&& Arref;
typedef const A&& cArref;
typedef volatile A&& vArref;
typedef const volatile A&& cvArref;
template <class T, bool is_lvalue_ref, bool is_rvalue_ref, bool s_const, bool s_volatile>
void test()
{
sa<is_lvalue_reference<T>::value == is_lvalue_ref> t1;
sa<is_rvalue_reference<T>::value == is_rvalue_ref> t2;
sa<is_const <typename remove_reference<T>::type>::value == s_const> t3;
sa<is_volatile<typename remove_reference<T>::type>::value == s_volatile> t4;
sa<is_const <typename remove_reference<const T>::type>::value == s_const > t5;
sa<is_volatile<typename remove_reference< volatile T>::type>::value == s_volatile> t6;
}
int main()
{
// sanity check
test< A&, true, false, false, false>();
test<const A&, true, false, true, false>();
test< volatile A&, true, false, false, true>();
test<const volatile A&, true, false, true, true>();
test< A&&, false, true, false, false>();
test<const A&&, false, true, true, false>();
test< volatile A&&, false, true, false, true>();
test<const volatile A&&, false, true, true, true>();
// lvalue reference test
// Alref
test< Alref&, true, false, false, false>();
test<const Alref&, true, false, false, false>();
test< volatile Alref&, true, false, false, false>();
test<const volatile Alref&, true, false, false, false>();
// cAlref
test< cAlref&, true, false, true, false>();
test<const cAlref&, true, false, true, false>();
test< volatile cAlref&, true, false, true, false>();
test<const volatile cAlref&, true, false, true, false>();
// vAlref
test< vAlref&, true, false, false, true>();
test<const vAlref&, true, false, false, true>();
test< volatile vAlref&, true, false, false, true>();
test<const volatile vAlref&, true, false, false, true>();
// cvAlref
test< cvAlref&, true, false, true, true>();
test<const cvAlref&, true, false, true, true>();
test< volatile cvAlref&, true, false, true, true>();
test<const volatile cvAlref&, true, false, true, true>();
// Arref
test< Arref&, true, false, false, false>();
test<const Arref&, true, false, false, false>();
test< volatile Arref&, true, false, false, false>();
test<const volatile Arref&, true, false, false, false>();
// cArref
test< cArref&, true, false, true, false>();
test<const cArref&, true, false, true, false>();
test< volatile cArref&, true, false, true, false>();
test<const volatile cArref&, true, false, true, false>();
// vArref
test< vArref&, true, false, false, true>();
test<const vArref&, true, false, false, true>();
test< volatile vArref&, true, false, false, true>();
test<const volatile vArref&, true, false, false, true>();
// vArref
test< cvArref&, true, false, true, true>();
test<const cvArref&, true, false, true, true>();
test< volatile cvArref&, true, false, true, true>();
test<const volatile cvArref&, true, false, true, true>();
// rvalue reference test
// Alref
test< Alref&&, true, false, false, false>();
test<const Alref&&, true, false, false, false>();
test< volatile Alref&&, true, false, false, false>();
test<const volatile Alref&&, true, false, false, false>();
// cAlref
test< cAlref&&, true, false, true, false>();
test<const cAlref&&, true, false, true, false>();
test< volatile cAlref&&, true, false, true, false>();
test<const volatile cAlref&&, true, false, true, false>();
// vAlref
test< vAlref&&, true, false, false, true>();
test<const vAlref&&, true, false, false, true>();
test< volatile vAlref&&, true, false, false, true>();
test<const volatile vAlref&&, true, false, false, true>();
// cvAlref
test< cvAlref&&, true, false, true, true>();
test<const cvAlref&&, true, false, true, true>();
test< volatile cvAlref&&, true, false, true, true>();
test<const volatile cvAlref&&, true, false, true, true>();
// Arref
test< Arref&&, false, true, false, false>();
test<const Arref&&, false, true, false, false>();
test< volatile Arref&&, false, true, false, false>();
test<const volatile Arref&&, false, true, false, false>();
// cArref
test< cArref&&, false, true, true, false>();
test<const cArref&&, false, true, true, false>();
test< volatile cArref&&, false, true, true, false>();
test<const volatile cArref&&, false, true, true, false>();
// vArref
test< vArref&&, false, true, false, true>();
test<const vArref&&, false, true, false, true>();
test< volatile vArref&&, false, true, false, true>();
test<const volatile vArref&&, false, true, false, true>();
// cvArref
test< cvArref&&, false, true, true, true>();
test<const cvArref&&, false, true, true, true>();
test< volatile cvArref&&, false, true, true, true>();
test<const volatile cvArref&&, false, true, true, true>();
return 0;
}

149
gcc/testsuite/g++.dg/cpp0x/rv1n.C Normal file
View file

@ -0,0 +1,149 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 1 at a time
one sink_1_1( A&); // { dg-error "" }
int test1_1()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_1(ca); // { dg-error "invalid initialization" }
sink_1_1(va); // { dg-error "invalid initialization" }
sink_1_1(cva); // { dg-error "invalid initialization" }
sink_1_1(source()); // { dg-error "invalid initialization" }
sink_1_1(c_source()); // { dg-error "invalid initialization" }
sink_1_1(v_source()); // { dg-error "invalid initialization" }
sink_1_1(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
two sink_1_2(const A&); // { dg-error "" }
int test1_2()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_2(va); // { dg-error "invalid initialization" }
sink_1_2(cva); // { dg-error "invalid initialization" }
sink_1_2(v_source()); // { dg-error "invalid initialization" }
sink_1_2(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
three sink_1_3(volatile A&); // { dg-error "" }
int test1_3()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_3(ca); // { dg-error "invalid initialization" }
sink_1_3(cva); // { dg-error "invalid initialization" }
sink_1_3(source()); // { dg-error "invalid initialization" }
sink_1_3(c_source()); // { dg-error "invalid initialization" }
sink_1_3(v_source()); // { dg-error "invalid initialization" }
sink_1_3(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
four sink_1_4(const volatile A&); // { dg-error "" }
int test1_4()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_4(source()); // { dg-error "invalid initialization" }
sink_1_4(c_source()); // { dg-error "invalid initialization" }
sink_1_4(v_source()); // { dg-error "invalid initialization" }
sink_1_4(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
five sink_1_5( A&&); // { dg-error "" }
int test1_5()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_5(ca); // { dg-error "invalid initialization" }
sink_1_5(va); // { dg-error "invalid initialization" }
sink_1_5(cva); // { dg-error "invalid initialization" }
sink_1_5(c_source()); // { dg-error "invalid initialization" }
sink_1_5(v_source()); // { dg-error "invalid initialization" }
sink_1_5(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
six sink_1_6(const A&&); // { dg-error "" }
int test1_6()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_6(va); // { dg-error "invalid initialization" }
sink_1_6(cva); // { dg-error "invalid initialization" }
sink_1_6(v_source()); // { dg-error "invalid initialization" }
sink_1_6(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
seven sink_1_7(volatile A&&); // { dg-error "" }
int test1_7()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_1_7(ca); // { dg-error "invalid initialization" }
sink_1_7(cva); // { dg-error "invalid initialization" }
sink_1_7(c_source()); // { dg-error "invalid initialization" }
sink_1_7(cv_source()); // { dg-error "invalid initialization" }
return 0;
}
int main()
{
return test1_1() + test1_2() + test1_3() + test1_5() +
test1_6() + test1_7();
}

154
gcc/testsuite/g++.dg/cpp0x/rv1p.C Normal file
View file

@ -0,0 +1,154 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 1 at a time
one sink_1_1( A&);
int test1_1()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_1(a)) == 1> t1;
return 0;
}
two sink_1_2(const A&);
int test1_2()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_2(a)) == 2> t1;
sa<sizeof(sink_1_2(ca)) == 2> t2;
sa<sizeof(sink_1_2(source())) == 2> t5;
sa<sizeof(sink_1_2(c_source())) == 2> t6;
return 0;
}
three sink_1_3(volatile A&);
int test1_3()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_3(a)) == 3> t1;
sa<sizeof(sink_1_3(va)) == 3> t3;
return 0;
}
four sink_1_4(const volatile A&);
int test1_4()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_4(a)) == 4> t1;
sa<sizeof(sink_1_4(ca)) == 4> t2;
sa<sizeof(sink_1_4(va)) == 4> t3;
sa<sizeof(sink_1_4(cva)) == 4> t4;
return 0;
}
five sink_1_5( A&&);
int test1_5()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_5(a)) == 5> t1;
sa<sizeof(sink_1_5(source())) == 5> t5;
return 0;
}
six sink_1_6(const A&&);
int test1_6()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_6(a)) == 6> t1;
sa<sizeof(sink_1_6(ca)) == 6> t2;
sa<sizeof(sink_1_6(source())) == 6> t5;
sa<sizeof(sink_1_6(c_source())) == 6> t6;
return 0;
}
seven sink_1_7(volatile A&&);
int test1_7()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_7(a)) == 7> t1;
sa<sizeof(sink_1_7(va)) == 7> t3;
sa<sizeof(sink_1_7(source())) == 7> t5;
sa<sizeof(sink_1_7(v_source())) == 7> t7;
return 0;
}
eight sink_1_8(const volatile A&&);
int test1_8()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_1_8(a)) == 8> t1;
sa<sizeof(sink_1_8(ca)) == 8> t2;
sa<sizeof(sink_1_8(va)) == 8> t3;
sa<sizeof(sink_1_8(cva)) == 8> t4;
sa<sizeof(sink_1_8(source())) == 8> t5;
sa<sizeof(sink_1_8(c_source())) == 8> t6;
sa<sizeof(sink_1_8(v_source())) == 8> t7;
sa<sizeof(sink_1_8(cv_source())) == 8> t8;
return 0;
}
int main()
{
return test1_1() + test1_2() + test1_3() + test1_4() +
test1_5() + test1_6() + test1_7() + test1_8();
}

370
gcc/testsuite/g++.dg/cpp0x/rv2n.C Normal file
View file

@ -0,0 +1,370 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 2 at a time
one sink_2_12( A&); // { dg-error "" }
two sink_2_12(const A&); // { dg-error "" }
int test2_12()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_12(va); // { dg-error "no match" }
sink_2_12(cva); // { dg-error "no match" }
sink_2_12(v_source()); // { dg-error "no match" }
sink_2_12(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_2_13( A&); // { dg-error "" }
three sink_2_13(volatile A&); // { dg-error "" }
int test2_13()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_13(ca); // { dg-error "no match" }
sink_2_13(cva); // { dg-error "no match" }
sink_2_13(source()); // { dg-error "no match" }
sink_2_13(c_source()); // { dg-error "no match" }
sink_2_13(v_source()); // { dg-error "no match" }
sink_2_13(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_2_14( A&); // { dg-error "" }
four sink_2_14(const volatile A&); // { dg-error "" }
int test2_14()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_14(source()); // { dg-error "no match" }
sink_2_14(c_source()); // { dg-error "no match" }
sink_2_14(v_source()); // { dg-error "no match" }
sink_2_14(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_2_15( A&); // { dg-error "" }
five sink_2_15( A&&); // { dg-error "" }
int test2_15()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_15(ca); // { dg-error "no match" }
sink_2_15(va); // { dg-error "no match" }
sink_2_15(cva); // { dg-error "no match" }
sink_2_15(c_source()); // { dg-error "no match" }
sink_2_15(v_source()); // { dg-error "no match" }
sink_2_15(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_2_16( A&); // { dg-error "" }
six sink_2_16(const A&&); // { dg-error "" }
int test2_16()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_16(va); // { dg-error "no match" }
sink_2_16(cva); // { dg-error "no match" }
sink_2_16(v_source()); // { dg-error "no match" }
sink_2_16(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_2_17( A&); // { dg-error "" }
seven sink_2_17(volatile A&&); // { dg-error "" }
int test2_17()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_17(ca); // { dg-error "no match" }
sink_2_17(cva); // { dg-error "no match" }
sink_2_17(c_source()); // { dg-error "no match" }
sink_2_17(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_2_23(const A&); // { dg-error "" }
three sink_2_23(volatile A&); // { dg-error "" }
int test2_23()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_23(a); // { dg-error "ambiguous" }
sink_2_23(cva); // { dg-error "no match" }
sink_2_23(v_source()); // { dg-error "no match" }
sink_2_23(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_2_24(const A&); // { dg-error "" }
four sink_2_24(const volatile A&); // { dg-error "" }
int test2_24()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_24(v_source()); // { dg-error "no match" }
sink_2_24(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_2_34(volatile A&); // { dg-error "" }
four sink_2_34(const volatile A&); // { dg-error "" }
int test2_34()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_34(source()); // { dg-error "no match" }
sink_2_34(c_source()); // { dg-error "no match" }
sink_2_34(v_source()); // { dg-error "no match" }
sink_2_34(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_2_25(const A&); // { dg-error "" }
five sink_2_25( A&&); // { dg-error "" }
int test2_25()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_25(va); // { dg-error "no match" }
sink_2_25(cva); // { dg-error "no match" }
sink_2_25(v_source()); // { dg-error "no match" }
sink_2_25(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_2_26(const A&); // { dg-error "" }
six sink_2_26(const A&&); // { dg-error "" }
int test2_26()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_26(va); // { dg-error "no match" }
sink_2_26(cva); // { dg-error "no match" }
sink_2_26(v_source()); // { dg-error "no match" }
sink_2_26(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_2_27(const A&); // { dg-error "" }
seven sink_2_27(volatile A&&); // { dg-error "" }
int test2_27()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_27(cva); // { dg-error "no match" }
sink_2_27(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_2_35(volatile A&); // { dg-error "" }
five sink_2_35( A&&); // { dg-error "" }
int test2_35()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_35(ca); // { dg-error "no match" }
sink_2_35(cva); // { dg-error "no match" }
sink_2_35(c_source()); // { dg-error "no match" }
sink_2_35(v_source()); // { dg-error "no match" }
sink_2_35(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_2_36(volatile A&); // { dg-error "" }
six sink_2_36(const A&&); // { dg-error "" }
int test2_36()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_36(cva); // { dg-error "no match" }
sink_2_36(v_source()); // { dg-error "no match" }
sink_2_36(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_2_37(volatile A&); // { dg-error "" }
seven sink_2_37(volatile A&&); // { dg-error "" }
int test2_37()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_37(ca); // { dg-error "no match" }
sink_2_37(cva); // { dg-error "no match" }
sink_2_37(c_source()); // { dg-error "no match" }
sink_2_37(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_2_45(const volatile A&); // { dg-error "" }
five sink_2_45( A&&); // { dg-error "" }
int test2_45()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_45(c_source()); // { dg-error "no match" }
sink_2_45(v_source()); // { dg-error "no match" }
sink_2_45(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_2_46(const volatile A&); // { dg-error "" }
six sink_2_46(const A&&); // { dg-error "" }
int test2_46()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_46(v_source()); // { dg-error "no match" }
sink_2_46(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_2_47(const volatile A&); // { dg-error "" }
seven sink_2_47(volatile A&&); // { dg-error "" }
int test2_47()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_47(c_source()); // { dg-error "no match" }
sink_2_47(cv_source()); // { dg-error "no match" }
return 0;
}
five sink_2_56( A&&); // { dg-error "" }
six sink_2_56(const A&&); // { dg-error "" }
int test2_56()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_56(va); // { dg-error "no match" }
sink_2_56(cva); // { dg-error "no match" }
sink_2_56(v_source()); // { dg-error "no match" }
sink_2_56(cv_source()); // { dg-error "no match" }
return 0;
}
five sink_2_57( A&&); // { dg-error "" }
seven sink_2_57(volatile A&&); // { dg-error "" }
int test2_57()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_57(ca); // { dg-error "no match" }
sink_2_57(cva); // { dg-error "no match" }
sink_2_57(c_source()); // { dg-error "no match" }
sink_2_57(cv_source()); // { dg-error "no match" }
return 0;
}
six sink_2_67(const A&&); // { dg-error "" }
seven sink_2_67(volatile A&&); // { dg-error "" }
int test2_67()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_2_67(a); // { dg-error "ambiguous" }
sink_2_67(cva); // { dg-error "no match" }
sink_2_67(source()); // { dg-error "ambiguous" }
sink_2_67(cv_source()); // { dg-error "no match" }
return 0;
}
int main()
{
return test2_12() + test2_13() + test2_15() + test2_16() +
test2_17() + test2_23() + test2_25() + test2_26() +
test2_27() + test2_35() + test2_36() + test2_37() +
test2_56() + test2_57() + test2_67();
}

536
gcc/testsuite/g++.dg/cpp0x/rv2p.C Normal file
View file

@ -0,0 +1,536 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 2 at a time
one sink_2_12( A&);
two sink_2_12(const A&);
int test2_12()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_12(a)) == 1> t1;
sa<sizeof(sink_2_12(ca)) == 2> t2;
sa<sizeof(sink_2_12(source())) == 2> t5;
sa<sizeof(sink_2_12(c_source())) == 2> t6;
return 0;
}
one sink_2_13( A&);
three sink_2_13(volatile A&);
int test2_13()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_13(a)) == 1> t1;
sa<sizeof(sink_2_13(va)) == 3> t3;
return 0;
}
one sink_2_14( A&);
four sink_2_14(const volatile A&);
int test2_14()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_14(a)) == 1> t1;
sa<sizeof(sink_2_14(ca)) == 4> t2;
sa<sizeof(sink_2_14(va)) == 4> t3;
sa<sizeof(sink_2_14(cva)) == 4> t4;
return 0;
}
one sink_2_15( A&);
five sink_2_15( A&&);
int test2_15()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_15(a)) == 1> t1;
sa<sizeof(sink_2_15(source())) == 5> t5;
return 0;
}
one sink_2_16( A&);
six sink_2_16(const A&&);
int test2_16()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_16(a)) == 1> t1;
sa<sizeof(sink_2_16(ca)) == 6> t2;
sa<sizeof(sink_2_16(source())) == 6> t5;
sa<sizeof(sink_2_16(c_source())) == 6> t6;
return 0;
}
one sink_2_17( A&);
seven sink_2_17(volatile A&&);
int test2_17()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_17(a)) == 1> t1;
sa<sizeof(sink_2_17(va)) == 7> t3;
sa<sizeof(sink_2_17(source())) == 7> t5;
sa<sizeof(sink_2_17(v_source())) == 7> t7;
return 0;
}
one sink_2_18( A&);
eight sink_2_18(const volatile A&&);
int test2_18()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_18(a)) == 1> t1;
sa<sizeof(sink_2_18(ca)) == 8> t2;
sa<sizeof(sink_2_18(va)) == 8> t3;
sa<sizeof(sink_2_18(cva)) == 8> t4;
sa<sizeof(sink_2_18(source())) == 8> t5;
sa<sizeof(sink_2_18(c_source())) == 8> t6;
sa<sizeof(sink_2_18(v_source())) == 8> t7;
sa<sizeof(sink_2_18(cv_source())) == 8> t8;
return 0;
}
two sink_2_23(const A&);
three sink_2_23(volatile A&);
int test2_23()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_23(ca)) == 2> t2;
sa<sizeof(sink_2_23(va)) == 3> t3;
sa<sizeof(sink_2_23(source())) == 2> t5;
sa<sizeof(sink_2_23(c_source())) == 2> t6;
return 0;
}
two sink_2_24(const A&);
four sink_2_24(const volatile A&);
int test2_24()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_24(a)) == 2> t1;
sa<sizeof(sink_2_24(ca)) == 2> t2;
sa<sizeof(sink_2_24(va)) == 4> t3;
sa<sizeof(sink_2_24(cva)) == 4> t4;
sa<sizeof(sink_2_24(source())) == 2> t5;
sa<sizeof(sink_2_24(c_source())) == 2> t6;
// sa<sizeof(sink_2_24(v_source())) == 4> t7;
// sa<sizeof(sink_2_24(cv_source())) == 4> t8;
return 0;
}
two sink_2_25(const A&);
five sink_2_25( A&&);
int test2_25()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_25(a)) == 2> t1;
sa<sizeof(sink_2_25(ca)) == 2> t2;
sa<sizeof(sink_2_25(source())) == 5> t5;
sa<sizeof(sink_2_25(c_source())) == 2> t6;
return 0;
}
two sink_2_26(const A&);
six sink_2_26(const A&&);
int test2_26()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_26(a)) == 2> t1;
sa<sizeof(sink_2_26(ca)) == 2> t2;
sa<sizeof(sink_2_26(source())) == 6> t5;
sa<sizeof(sink_2_26(c_source())) == 6> t6;
return 0;
}
two sink_2_27(const A&);
seven sink_2_27(volatile A&&);
int test2_27()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_27(a)) == 2> t1;
sa<sizeof(sink_2_27(ca)) == 2> t2;
sa<sizeof(sink_2_27(va)) == 7> t3;
sa<sizeof(sink_2_27(source())) == 7> t5;
sa<sizeof(sink_2_27(c_source())) == 2> t6;
sa<sizeof(sink_2_27(v_source())) == 7> t7;
return 0;
}
two sink_2_28(const A&);
eight sink_2_28(const volatile A&&);
int test2_28()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_28(a)) == 2> t1;
sa<sizeof(sink_2_28(ca)) == 2> t2;
sa<sizeof(sink_2_28(va)) == 8> t3;
sa<sizeof(sink_2_28(cva)) == 8> t4;
sa<sizeof(sink_2_28(source())) == 8> t5;
sa<sizeof(sink_2_28(c_source())) == 8> t6;
sa<sizeof(sink_2_28(v_source())) == 8> t7;
sa<sizeof(sink_2_28(cv_source())) == 8> t8;
return 0;
}
three sink_2_34(volatile A&);
four sink_2_34(const volatile A&);
int test2_34()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_34(a)) == 3> t1;
sa<sizeof(sink_2_34(ca)) == 4> t2;
sa<sizeof(sink_2_34(va)) == 3> t3;
sa<sizeof(sink_2_34(cva)) == 4> t4;
// sa<sizeof(sink_2_34(source())) == 4> t5;
// sa<sizeof(sink_2_34(c_source())) == 4> t6;
// sa<sizeof(sink_2_34(v_source())) == 4> t7;
// sa<sizeof(sink_2_34(cv_source())) == 4> t8;
return 0;
}
three sink_2_35(volatile A&);
five sink_2_35( A&&);
int test2_35()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_35(a)) == 3> t1;
sa<sizeof(sink_2_35(va)) == 3> t3;
sa<sizeof(sink_2_35(source())) == 5> t5;
return 0;
}
three sink_2_36(volatile A&);
six sink_2_36(const A&&);
int test2_36()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_36(a)) == 3> t1;
sa<sizeof(sink_2_36(ca)) == 6> t2;
sa<sizeof(sink_2_36(va)) == 3> t3;
sa<sizeof(sink_2_36(source())) == 6> t5;
sa<sizeof(sink_2_36(c_source())) == 6> t6;
return 0;
}
three sink_2_37(volatile A&);
seven sink_2_37(volatile A&&);
int test2_37()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_37(a)) == 3> t1;
sa<sizeof(sink_2_37(va)) == 3> t3;
sa<sizeof(sink_2_37(source())) == 7> t5;
sa<sizeof(sink_2_37(v_source())) == 7> t7;
return 0;
}
three sink_2_38(volatile A&);
eight sink_2_38(const volatile A&&);
int test2_38()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_38(a)) == 3> t1;
sa<sizeof(sink_2_38(ca)) == 8> t2;
sa<sizeof(sink_2_38(va)) == 3> t3;
sa<sizeof(sink_2_38(cva)) == 8> t4;
sa<sizeof(sink_2_38(source())) == 8> t5;
sa<sizeof(sink_2_38(c_source())) == 8> t6;
sa<sizeof(sink_2_38(v_source())) == 8> t7;
sa<sizeof(sink_2_38(cv_source())) == 8> t8;
return 0;
}
four sink_2_45(const volatile A&);
five sink_2_45( A&&);
int test2_45()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_45(a)) == 4> t1;
sa<sizeof(sink_2_45(ca)) == 4> t2;
sa<sizeof(sink_2_45(va)) == 4> t3;
sa<sizeof(sink_2_45(cva)) == 4> t4;
sa<sizeof(sink_2_45(source())) == 5> t5;
// sa<sizeof(sink_2_45(c_source())) == 4> t6;
// sa<sizeof(sink_2_45(v_source())) == 4> t7;
// sa<sizeof(sink_2_45(cv_source())) == 4> t8;
return 0;
}
four sink_2_46(const volatile A&);
six sink_2_46(const A&&);
int test2_46()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_46(a)) == 4> t1;
sa<sizeof(sink_2_46(ca)) == 4> t2;
sa<sizeof(sink_2_46(va)) == 4> t3;
sa<sizeof(sink_2_46(cva)) == 4> t4;
sa<sizeof(sink_2_46(source())) == 6> t5;
sa<sizeof(sink_2_46(c_source())) == 6> t6;
// sa<sizeof(sink_2_46(v_source())) == 4> t7;
// sa<sizeof(sink_2_46(cv_source())) == 4> t8;
return 0;
}
four sink_2_47(const volatile A&);
seven sink_2_47(volatile A&&);
int test2_47()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_47(a)) == 4> t1;
sa<sizeof(sink_2_47(ca)) == 4> t2;
sa<sizeof(sink_2_47(va)) == 4> t3;
sa<sizeof(sink_2_47(cva)) == 4> t4;
sa<sizeof(sink_2_47(source())) == 7> t5;
// sa<sizeof(sink_2_47(c_source())) == 4> t6;
sa<sizeof(sink_2_47(v_source())) == 7> t7;
// sa<sizeof(sink_2_47(cv_source())) == 4> t8;
return 0;
}
four sink_2_48(const volatile A&);
eight sink_2_48(const volatile A&&);
int test2_48()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_48(a)) == 4> t1;
sa<sizeof(sink_2_48(ca)) == 4> t2;
sa<sizeof(sink_2_48(va)) == 4> t3;
sa<sizeof(sink_2_48(cva)) == 4> t4;
sa<sizeof(sink_2_48(source())) == 8> t5;
sa<sizeof(sink_2_48(c_source())) == 8> t6;
sa<sizeof(sink_2_48(v_source())) == 8> t7;
sa<sizeof(sink_2_48(cv_source())) == 8> t8;
return 0;
}
five sink_2_56( A&&);
six sink_2_56(const A&&);
int test2_56()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_56(a)) == 5> t1;
sa<sizeof(sink_2_56(ca)) == 6> t2;
sa<sizeof(sink_2_56(source())) == 5> t5;
sa<sizeof(sink_2_56(c_source())) == 6> t6;
return 0;
}
five sink_2_57( A&&);
seven sink_2_57(volatile A&&);
int test2_57()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_57(a)) == 5> t1;
sa<sizeof(sink_2_57(va)) == 7> t3;
sa<sizeof(sink_2_57(source())) == 5> t5;
sa<sizeof(sink_2_57(v_source())) == 7> t7;
return 0;
}
five sink_2_58( A&&);
eight sink_2_58(const volatile A&&);
int test2_58()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_58(a)) == 5> t1;
sa<sizeof(sink_2_58(ca)) == 8> t2;
sa<sizeof(sink_2_58(va)) == 8> t3;
sa<sizeof(sink_2_58(cva)) == 8> t4;
sa<sizeof(sink_2_58(source())) == 5> t5;
sa<sizeof(sink_2_58(c_source())) == 8> t6;
sa<sizeof(sink_2_58(v_source())) == 8> t7;
sa<sizeof(sink_2_58(cv_source())) == 8> t8;
return 0;
}
six sink_2_67(const A&&);
seven sink_2_67(volatile A&&);
int test2_67()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_67(ca)) == 6> t2;
sa<sizeof(sink_2_67(va)) == 7> t3;
sa<sizeof(sink_2_67(c_source())) == 6> t6;
sa<sizeof(sink_2_67(v_source())) == 7> t7;
return 0;
}
six sink_2_68(const A&&);
eight sink_2_68(const volatile A&&);
int test2_68()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_68(a)) == 6> t1;
sa<sizeof(sink_2_68(ca)) == 6> t2;
sa<sizeof(sink_2_68(va)) == 8> t3;
sa<sizeof(sink_2_68(cva)) == 8> t4;
sa<sizeof(sink_2_68(source())) == 6> t5;
sa<sizeof(sink_2_68(c_source())) == 6> t6;
sa<sizeof(sink_2_68(v_source())) == 8> t7;
sa<sizeof(sink_2_68(cv_source())) == 8> t8;
return 0;
}
seven sink_2_78(volatile A&&);
eight sink_2_78(const volatile A&&);
int test2_78()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_2_78(a)) == 7> t1;
sa<sizeof(sink_2_78(ca)) == 8> t2;
sa<sizeof(sink_2_78(va)) == 7> t3;
sa<sizeof(sink_2_78(cva)) == 8> t4;
sa<sizeof(sink_2_78(source())) == 7> t5;
sa<sizeof(sink_2_78(c_source())) == 8> t6;
sa<sizeof(sink_2_78(v_source())) == 7> t7;
sa<sizeof(sink_2_78(cv_source())) == 8> t8;
return 0;
}
int main()
{
return test2_12() + test2_13() + test2_14() + test2_15() +
test2_16() + test2_17() + test2_18() + test2_23() +
test2_24() + test2_25() + test2_26() + test2_27() +
test2_28() + test2_34() + test2_35() + test2_36() +
test2_37() + test2_38() + test2_45() + test2_46() +
test2_47() + test2_48() + test2_56() + test2_57() +
test2_58() + test2_67() + test2_68() + test2_78();
}

627
gcc/testsuite/g++.dg/cpp0x/rv3n.C Normal file
View file

@ -0,0 +1,627 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 3 at a time
one sink_3_123( A&); // { dg-error "" }
two sink_3_123(const A&); // { dg-error "" }
three sink_3_123(volatile A&); // { dg-error "" }
int test3_123()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_123(cva); // { dg-error "no match" }
sink_3_123(v_source()); // { dg-error "no match" }
sink_3_123(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_125( A&); // { dg-error "" }
two sink_3_125(const A&); // { dg-error "" }
five sink_3_125( A&&); // { dg-error "" }
one sink_3_124( A&); // { dg-error "" }
two sink_3_124(const A&); // { dg-error "" }
four sink_3_124(const volatile A&); // { dg-error "" }
int test3_124()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_124(v_source()); // { dg-error "no match" }
sink_3_124(cv_source()); // { dg-error "no match" }
return 0;
}
int test3_125()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_125(va); // { dg-error "no match" }
sink_3_125(cva); // { dg-error "no match" }
sink_3_125(v_source()); // { dg-error "no match" }
sink_3_125(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_126( A&); // { dg-error "" }
two sink_3_126(const A&); // { dg-error "" }
six sink_3_126(const A&&); // { dg-error "" }
int test3_126()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_126(va); // { dg-error "no match" }
sink_3_126(cva); // { dg-error "no match" }
sink_3_126(v_source()); // { dg-error "no match" }
sink_3_126(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_127( A&); // { dg-error "" }
two sink_3_127(const A&); // { dg-error "" }
seven sink_3_127(volatile A&&); // { dg-error "" }
int test3_127()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_127(cva); // { dg-error "no match" }
sink_3_127(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_134( A&); // { dg-error "" }
three sink_3_134(volatile A&); // { dg-error "" }
four sink_3_134(const volatile A&); // { dg-error "" }
int test3_134()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_134(source()); // { dg-error "no match" }
sink_3_134(c_source()); // { dg-error "no match" }
sink_3_134(v_source()); // { dg-error "no match" }
sink_3_134(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_135( A&); // { dg-error "" }
three sink_3_135(volatile A&); // { dg-error "" }
five sink_3_135( A&&); // { dg-error "" }
int test3_135()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_135(ca); // { dg-error "no match" }
sink_3_135(cva); // { dg-error "no match" }
sink_3_135(c_source()); // { dg-error "no match" }
sink_3_135(v_source()); // { dg-error "no match" }
sink_3_135(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_136( A&); // { dg-error "" }
three sink_3_136(volatile A&); // { dg-error "" }
six sink_3_136(const A&&); // { dg-error "" }
int test3_136()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_136(cva); // { dg-error "no match" }
sink_3_136(v_source()); // { dg-error "no match" }
sink_3_136(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_137( A&); // { dg-error "" }
three sink_3_137(volatile A&); // { dg-error "" }
seven sink_3_137(volatile A&&); // { dg-error "" }
int test3_137()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_137(ca); // { dg-error "no match" }
sink_3_137(cva); // { dg-error "no match" }
sink_3_137(c_source()); // { dg-error "no match" }
sink_3_137(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_145( A&); // { dg-error "" }
four sink_3_145(const volatile A&); // { dg-error "" }
five sink_3_145( A&&); // { dg-error "" }
int test3_145()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_145(c_source()); // { dg-error "no match" }
sink_3_145(v_source()); // { dg-error "no match" }
sink_3_145(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_146( A&); // { dg-error "" }
four sink_3_146(const volatile A&); // { dg-error "" }
six sink_3_146(const A&&); // { dg-error "" }
int test3_146()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_146(v_source()); // { dg-error "no match" }
sink_3_146(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_147( A&); // { dg-error "" }
four sink_3_147(const volatile A&); // { dg-error "" }
seven sink_3_147(volatile A&&); // { dg-error "" }
int test3_147()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_147(c_source()); // { dg-error "no match" }
sink_3_147(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_156( A&); // { dg-error "" }
five sink_3_156( A&&); // { dg-error "" }
six sink_3_156(const A&&); // { dg-error "" }
int test3_156()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_156(va); // { dg-error "no match" }
sink_3_156(cva); // { dg-error "no match" }
sink_3_156(v_source()); // { dg-error "no match" }
sink_3_156(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_157( A&); // { dg-error "" }
five sink_3_157( A&&); // { dg-error "" }
seven sink_3_157(volatile A&&); // { dg-error "" }
int test3_157()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_157(ca); // { dg-error "no match" }
sink_3_157(cva); // { dg-error "no match" }
sink_3_157(c_source()); // { dg-error "no match" }
sink_3_157(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_3_167( A&); // { dg-error "" }
six sink_3_167(const A&&); // { dg-error "" }
seven sink_3_167(volatile A&&); // { dg-error "" }
int test3_167()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_167(cva); // { dg-error "no match" }
sink_3_167(source()); // { dg-error "ambiguous" }
sink_3_167(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_234(const A&); // { dg-error "" }
three sink_3_234(volatile A&); // { dg-error "" }
four sink_3_234(const volatile A&); // { dg-error "" }
int test3_234()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_234(a); // { dg-error "ambiguous" }
sink_3_234(v_source()); // { dg-error "no match" }
sink_3_234(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_235(const A&); // { dg-error "" }
three sink_3_235(volatile A&); // { dg-error "" }
five sink_3_235( A&&); // { dg-error "" }
int test3_235()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_235(a); // { dg-error "ambiguous" }
sink_3_235(cva); // { dg-error "no match" }
sink_3_235(v_source()); // { dg-error "no match" }
sink_3_235(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_236(const A&); // { dg-error "" }
three sink_3_236(volatile A&); // { dg-error "" }
six sink_3_236(const A&&); // { dg-error "" }
int test3_236()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_236(a); // { dg-error "ambiguous" }
sink_3_236(cva); // { dg-error "no match" }
sink_3_236(v_source()); // { dg-error "no match" }
sink_3_236(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_237(const A&); // { dg-error "" }
three sink_3_237(volatile A&); // { dg-error "" }
seven sink_3_237(volatile A&&); // { dg-error "" }
int test3_237()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_237(a); // { dg-error "ambiguous" }
sink_3_237(cva); // { dg-error "no match" }
sink_3_237(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_238(const A&); // { dg-error "" }
three sink_3_238(volatile A&); // { dg-error "" }
eight sink_3_238(const volatile A&&); // { dg-error "" }
int test3_238()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_238(a); // { dg-error "ambiguous" }
return 0;
}
two sink_3_245(const A&); // { dg-error "" }
four sink_3_245(const volatile A&); // { dg-error "" }
five sink_3_245( A&&); // { dg-error "" }
int test3_245()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_245(v_source()); // { dg-error "no match" }
sink_3_245(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_246(const A&); // { dg-error "" }
four sink_3_246(const volatile A&); // { dg-error "" }
six sink_3_246(const A&&); // { dg-error "" }
int test3_246()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_246(v_source()); // { dg-error "no match" }
sink_3_246(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_247(const A&); // { dg-error "" }
four sink_3_247(const volatile A&); // { dg-error "" }
seven sink_3_247(volatile A&&); // { dg-error "" }
int test3_247()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_247(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_256(const A&); // { dg-error "" }
five sink_3_256( A&&); // { dg-error "" }
six sink_3_256(const A&&); // { dg-error "" }
int test3_256()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_256(va); // { dg-error "no match" }
sink_3_256(cva); // { dg-error "no match" }
sink_3_256(v_source()); // { dg-error "no match" }
sink_3_256(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_257(const A&); // { dg-error "" }
five sink_3_257( A&&); // { dg-error "" }
seven sink_3_257(volatile A&&); // { dg-error "" }
int test3_257()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_257(cva); // { dg-error "no match" }
sink_3_257(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_3_267(const A&); // { dg-error "" }
six sink_3_267(const A&&); // { dg-error "" }
seven sink_3_267(volatile A&&); // { dg-error "" }
int test3_267()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_267(cva); // { dg-error "no match" }
sink_3_267(source()); // { dg-error "ambiguous" }
sink_3_267(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_345(volatile A&); // { dg-error "" }
four sink_3_345(const volatile A&); // { dg-error "" }
five sink_3_345( A&&); // { dg-error "" }
int test3_345()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_345(c_source()); // { dg-error "no match" }
sink_3_345(v_source()); // { dg-error "no match" }
sink_3_345(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_346(volatile A&); // { dg-error "" }
four sink_3_346(const volatile A&); // { dg-error "" }
six sink_3_346(const A&&); // { dg-error "" }
int test3_346()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_346(v_source()); // { dg-error "no match" }
sink_3_346(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_347(volatile A&); // { dg-error "" }
four sink_3_347(const volatile A&); // { dg-error "" }
seven sink_3_347(volatile A&&); // { dg-error "" }
int test3_347()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_347(c_source()); // { dg-error "no match" }
sink_3_347(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_356(volatile A&); // { dg-error "" }
five sink_3_356( A&&); // { dg-error "" }
six sink_3_356(const A&&); // { dg-error "" }
int test3_356()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_356(cva); // { dg-error "no match" }
sink_3_356(v_source()); // { dg-error "no match" }
sink_3_356(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_357(volatile A&); // { dg-error "" }
five sink_3_357( A&&); // { dg-error "" }
seven sink_3_357(volatile A&&); // { dg-error "" }
int test3_357()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_357(ca); // { dg-error "no match" }
sink_3_357(cva); // { dg-error "no match" }
sink_3_357(c_source()); // { dg-error "no match" }
sink_3_357(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_3_367(volatile A&); // { dg-error "" }
six sink_3_367(const A&&); // { dg-error "" }
seven sink_3_367(volatile A&&); // { dg-error "" }
int test3_367()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_367(cva); // { dg-error "no match" }
sink_3_367(source()); // { dg-error "ambiguous" }
sink_3_367(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_3_456(const volatile A&); // { dg-error "" }
five sink_3_456( A&&); // { dg-error "" }
six sink_3_456(const A&&); // { dg-error "" }
int test3_456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_456(v_source()); // { dg-error "no match" }
sink_3_456(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_3_457(const volatile A&); // { dg-error "" }
five sink_3_457( A&&); // { dg-error "" }
seven sink_3_457(volatile A&&); // { dg-error "" }
int test3_457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_457(c_source()); // { dg-error "no match" }
sink_3_457(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_3_467(const volatile A&); // { dg-error "" }
six sink_3_467(const A&&); // { dg-error "" }
seven sink_3_467(volatile A&&); // { dg-error "" }
int test3_467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_467(source()); // { dg-error "ambiguous" }
sink_3_467(cv_source()); // { dg-error "no match" }
return 0;
}
five sink_3_567( A&&); // { dg-error "" }
six sink_3_567(const A&&); // { dg-error "" }
seven sink_3_567(volatile A&&); // { dg-error "" }
int test3_567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_567(cva); // { dg-error "no match" }
sink_3_567(cv_source()); // { dg-error "no match" }
return 0;
}
six sink_3_678(const A&&); // { dg-error "" }
seven sink_3_678(volatile A&&); // { dg-error "" }
eight sink_3_678(const volatile A&&); // { dg-error "" }
int test3_678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_3_678(a); // { dg-error "ambiguous" }
sink_3_678(source()); // { dg-error "ambiguous" }
return 0;
}
int main()
{
return test3_123() + test3_125() + test3_126() + test3_127() +
test3_135() + test3_136() + test3_137() + test3_156() +
test3_157() + test3_167() + test3_234() + test3_235() +
test3_236() + test3_237() + test3_238() + test3_256() +
test3_257() + test3_267() + test3_356() + test3_357() +
test3_367() + test3_467() + test3_567() + test3_678();
}

1120
gcc/testsuite/g++.dg/cpp0x/rv3p.C Normal file
View file

File diff suppressed because it is too large Load diff

735
gcc/testsuite/g++.dg/cpp0x/rv4n.C Normal file
View file

@ -0,0 +1,735 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 4 at a time
one sink_4_1234( A&); // { dg-error "" }
two sink_4_1234(const A&); // { dg-error "" }
three sink_4_1234(volatile A&); // { dg-error "" }
four sink_4_1234(const volatile A&); // { dg-error "" }
int test4_1234()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1234(v_source()); // { dg-error "no match" }
sink_4_1234(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1235( A&); // { dg-error "" }
two sink_4_1235(const A&); // { dg-error "" }
three sink_4_1235(volatile A&); // { dg-error "" }
five sink_4_1235( A&&); // { dg-error "" }
int test4_1235()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1235(cva); // { dg-error "no match" }
sink_4_1235(v_source()); // { dg-error "no match" }
sink_4_1235(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1236( A&); // { dg-error "" }
two sink_4_1236(const A&); // { dg-error "" }
three sink_4_1236(volatile A&); // { dg-error "" }
six sink_4_1236(const A&&); // { dg-error "" }
int test4_1236()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1236(cva); // { dg-error "no match" }
sink_4_1236(v_source()); // { dg-error "no match" }
sink_4_1236(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1237( A&); // { dg-error "" }
two sink_4_1237(const A&); // { dg-error "" }
three sink_4_1237(volatile A&); // { dg-error "" }
seven sink_4_1237(volatile A&&); // { dg-error "" }
int test4_1237()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1237(cva); // { dg-error "no match" }
sink_4_1237(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1245( A&); // { dg-error "" }
two sink_4_1245(const A&); // { dg-error "" }
four sink_4_1245(const volatile A&); // { dg-error "" }
five sink_4_1245( A&&); // { dg-error "" }
int test4_1245()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1245(v_source()); // { dg-error "no match" }
sink_4_1245(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1246( A&); // { dg-error "" }
two sink_4_1246(const A&); // { dg-error "" }
four sink_4_1246(const volatile A&); // { dg-error "" }
six sink_4_1246(const A&&); // { dg-error "" }
int test4_1246()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1246(v_source()); // { dg-error "no match" }
sink_4_1246(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1247( A&); // { dg-error "" }
two sink_4_1247(const A&); // { dg-error "" }
four sink_4_1247(const volatile A&); // { dg-error "" }
seven sink_4_1247(volatile A&&); // { dg-error "" }
int test4_1247()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1247(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1256( A&); // { dg-error "" }
two sink_4_1256(const A&); // { dg-error "" }
five sink_4_1256( A&&); // { dg-error "" }
six sink_4_1256(const A&&); // { dg-error "" }
int test4_1256()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1256(va); // { dg-error "no match" }
sink_4_1256(cva); // { dg-error "no match" }
sink_4_1256(v_source()); // { dg-error "no match" }
sink_4_1256(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1257( A&); // { dg-error "" }
two sink_4_1257(const A&); // { dg-error "" }
five sink_4_1257( A&&); // { dg-error "" }
seven sink_4_1257(volatile A&&); // { dg-error "" }
int test4_1257()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1257(cva); // { dg-error "no match" }
sink_4_1257(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1267( A&); // { dg-error "" }
two sink_4_1267(const A&); // { dg-error "" }
six sink_4_1267(const A&&); // { dg-error "" }
seven sink_4_1267(volatile A&&); // { dg-error "" }
int test4_1267()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1267(cva); // { dg-error "no match" }
sink_4_1267(source()); // { dg-error "ambiguous" }
sink_4_1267(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1345( A&); // { dg-error "" }
three sink_4_1345(volatile A&); // { dg-error "" }
four sink_4_1345(const volatile A&); // { dg-error "" }
five sink_4_1345( A&&); // { dg-error "" }
int test4_1345()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1345(c_source()); // { dg-error "no match" }
sink_4_1345(v_source()); // { dg-error "no match" }
sink_4_1345(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1346( A&); // { dg-error "" }
three sink_4_1346(volatile A&); // { dg-error "" }
four sink_4_1346(const volatile A&); // { dg-error "" }
six sink_4_1346(const A&&); // { dg-error "" }
int test4_1346()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1346(v_source()); // { dg-error "no match" }
sink_4_1346(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1347( A&); // { dg-error "" }
three sink_4_1347(volatile A&); // { dg-error "" }
four sink_4_1347(const volatile A&); // { dg-error "" }
seven sink_4_1347(volatile A&&); // { dg-error "" }
int test4_1347()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1347(c_source()); // { dg-error "no match" }
sink_4_1347(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1356( A&); // { dg-error "" }
three sink_4_1356(volatile A&); // { dg-error "" }
five sink_4_1356( A&&); // { dg-error "" }
six sink_4_1356(const A&&); // { dg-error "" }
int test4_1356()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1356(cva); // { dg-error "no match" }
sink_4_1356(v_source()); // { dg-error "no match" }
sink_4_1356(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1357( A&); // { dg-error "" }
three sink_4_1357(volatile A&); // { dg-error "" }
five sink_4_1357( A&&); // { dg-error "" }
seven sink_4_1357(volatile A&&); // { dg-error "" }
int test4_1357()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1357(ca); // { dg-error "no match" }
sink_4_1357(cva); // { dg-error "no match" }
sink_4_1357(c_source()); // { dg-error "no match" }
sink_4_1357(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1367( A&); // { dg-error "" }
three sink_4_1367(volatile A&); // { dg-error "" }
six sink_4_1367(const A&&); // { dg-error "" }
seven sink_4_1367(volatile A&&); // { dg-error "" }
int test4_1367()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1367(cva); // { dg-error "no match" }
sink_4_1367(source()); // { dg-error "ambiguous" }
sink_4_1367(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1456( A&); // { dg-error "" }
four sink_4_1456(const volatile A&); // { dg-error "" }
five sink_4_1456( A&&); // { dg-error "" }
six sink_4_1456(const A&&); // { dg-error "" }
int test4_1456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1456(v_source()); // { dg-error "no match" }
sink_4_1456(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1457( A&); // { dg-error "" }
four sink_4_1457(const volatile A&); // { dg-error "" }
five sink_4_1457( A&&); // { dg-error "" }
seven sink_4_1457(volatile A&&); // { dg-error "" }
int test4_1457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1457(c_source()); // { dg-error "no match" }
sink_4_1457(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1467( A&); // { dg-error "" }
four sink_4_1467(const volatile A&); // { dg-error "" }
six sink_4_1467(const A&&); // { dg-error "" }
seven sink_4_1467(volatile A&&); // { dg-error "" }
int test4_1467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1467(source()); // { dg-error "ambiguous" }
sink_4_1467(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1567( A&); // { dg-error "" }
five sink_4_1567( A&&); // { dg-error "" }
six sink_4_1567(const A&&); // { dg-error "" }
seven sink_4_1567(volatile A&&); // { dg-error "" }
int test4_1567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1567(cva); // { dg-error "no match" }
sink_4_1567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_4_1678( A&);
six sink_4_1678(const A&&); // { dg-error "" }
seven sink_4_1678(volatile A&&); // { dg-error "" }
eight sink_4_1678(const volatile A&&); // { dg-error "" }
int test4_1678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_1678(source()); // { dg-error "ambiguous" }
return 0;
}
two sink_4_2345(const A&); // { dg-error "" }
three sink_4_2345(volatile A&); // { dg-error "" }
four sink_4_2345(const volatile A&); // { dg-error "" }
five sink_4_2345( A&&); // { dg-error "" }
int test4_2345()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2345(a); // { dg-error "ambiguous" }
sink_4_2345(v_source()); // { dg-error "no match" }
sink_4_2345(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2346(const A&); // { dg-error "" }
three sink_4_2346(volatile A&); // { dg-error "" }
four sink_4_2346(const volatile A&); // { dg-error "" }
six sink_4_2346(const A&&); // { dg-error "" }
int test4_2346()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2346(a); // { dg-error "ambiguous" }
sink_4_2346(v_source()); // { dg-error "no match" }
sink_4_2346(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2347(const A&); // { dg-error "" }
three sink_4_2347(volatile A&); // { dg-error "" }
four sink_4_2347(const volatile A&); // { dg-error "" }
seven sink_4_2347(volatile A&&); // { dg-error "" }
int test4_2347()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2347(a); // { dg-error "ambiguous" }
sink_4_2347(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2348(const A&); // { dg-error "" }
three sink_4_2348(volatile A&); // { dg-error "" }
four sink_4_2348(const volatile A&); // { dg-error "" }
eight sink_4_2348(const volatile A&&); // { dg-error "" }
int test4_2348()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2348(a); // { dg-error "ambiguous" }
return 0;
}
two sink_4_2356(const A&); // { dg-error "" }
three sink_4_2356(volatile A&); // { dg-error "" }
five sink_4_2356( A&&); // { dg-error "" }
six sink_4_2356(const A&&); // { dg-error "" }
int test4_2356()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2356(a); // { dg-error "ambiguous" }
sink_4_2356(cva); // { dg-error "no match" }
sink_4_2356(v_source()); // { dg-error "no match" }
sink_4_2356(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2357(const A&); // { dg-error "" }
three sink_4_2357(volatile A&); // { dg-error "" }
five sink_4_2357( A&&); // { dg-error "" }
seven sink_4_2357(volatile A&&); // { dg-error "" }
int test4_2357()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2357(a); // { dg-error "ambiguous" }
sink_4_2357(cva); // { dg-error "no match" }
sink_4_2357(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2358(const A&); // { dg-error "" }
three sink_4_2358(volatile A&); // { dg-error "" }
five sink_4_2358( A&&); // { dg-error "" }
eight sink_4_2358(const volatile A&&); // { dg-error "" }
int test4_2358()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2358(a); // { dg-error "ambiguous" }
return 0;
}
two sink_4_2367(const A&); // { dg-error "" }
three sink_4_2367(volatile A&); // { dg-error "" }
six sink_4_2367(const A&&); // { dg-error "" }
seven sink_4_2367(volatile A&&); // { dg-error "" }
int test4_2367()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2367(a); // { dg-error "ambiguous" }
sink_4_2367(cva); // { dg-error "no match" }
sink_4_2367(source()); // { dg-error "ambiguous" }
sink_4_2367(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2368(const A&); // { dg-error "" }
three sink_4_2368(volatile A&); // { dg-error "" }
six sink_4_2368(const A&&); // { dg-error "" }
eight sink_4_2368(const volatile A&&); // { dg-error "" }
int test4_2368()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2368(a); // { dg-error "ambiguous" }
return 0;
}
two sink_4_2378(const A&); // { dg-error "" }
three sink_4_2378(volatile A&); // { dg-error "" }
seven sink_4_2378(volatile A&&); // { dg-error "" }
eight sink_4_2378(const volatile A&&); // { dg-error "" }
int test4_2378()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2378(a); // { dg-error "ambiguous" }
return 0;
}
two sink_4_2456(const A&); // { dg-error "" }
four sink_4_2456(const volatile A&); // { dg-error "" }
five sink_4_2456( A&&); // { dg-error "" }
six sink_4_2456(const A&&); // { dg-error "" }
int test4_2456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2456(v_source()); // { dg-error "no match" }
sink_4_2456(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2457(const A&); // { dg-error "" }
four sink_4_2457(const volatile A&); // { dg-error "" }
five sink_4_2457( A&&); // { dg-error "" }
seven sink_4_2457(volatile A&&); // { dg-error "" }
int test4_2457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2457(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2467(const A&); // { dg-error "" }
four sink_4_2467(const volatile A&); // { dg-error "" }
six sink_4_2467(const A&&); // { dg-error "" }
seven sink_4_2467(volatile A&&); // { dg-error "" }
int test4_2467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2467(source()); // { dg-error "ambiguous" }
sink_4_2467(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2567(const A&); // { dg-error "" }
five sink_4_2567( A&&); // { dg-error "" }
six sink_4_2567(const A&&); // { dg-error "" }
seven sink_4_2567(volatile A&&); // { dg-error "" }
int test4_2567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2567(cva); // { dg-error "no match" }
sink_4_2567(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_4_2678(const A&); // { dg-error "" }
six sink_4_2678(const A&&); // { dg-error "" }
seven sink_4_2678(volatile A&&); // { dg-error "" }
eight sink_4_2678(const volatile A&&); // { dg-error "" }
int test4_2678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_2678(source()); // { dg-error "ambiguous" }
return 0;
}
three sink_4_3456(volatile A&); // { dg-error "" }
four sink_4_3456(const volatile A&); // { dg-error "" }
five sink_4_3456( A&&); // { dg-error "" }
six sink_4_3456(const A&&); // { dg-error "" }
int test4_3456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_3456(v_source()); // { dg-error "no match" }
sink_4_3456(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_4_3457(volatile A&); // { dg-error "" }
four sink_4_3457(const volatile A&); // { dg-error "" }
five sink_4_3457( A&&); // { dg-error "" }
seven sink_4_3457(volatile A&&); // { dg-error "" }
int test4_3457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_3457(c_source()); // { dg-error "no match" }
sink_4_3457(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_4_3467(volatile A&); // { dg-error "" }
four sink_4_3467(const volatile A&); // { dg-error "" }
six sink_4_3467(const A&&); // { dg-error "" }
seven sink_4_3467(volatile A&&); // { dg-error "" }
int test4_3467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_3467(source()); // { dg-error "ambiguous" }
sink_4_3467(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_4_3567(volatile A&); // { dg-error "" }
five sink_4_3567( A&&); // { dg-error "" }
six sink_4_3567(const A&&); // { dg-error "" }
seven sink_4_3567(volatile A&&); // { dg-error "" }
int test4_3567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_3567(cva); // { dg-error "no match" }
sink_4_3567(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_4_3678(volatile A&);
six sink_4_3678(const A&&); // { dg-error "" }
seven sink_4_3678(volatile A&&); // { dg-error "" }
eight sink_4_3678(const volatile A&&); // { dg-error "" }
int test4_3678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_3678(source()); // { dg-error "ambiguous" }
return 0;
}
four sink_4_4567(const volatile A&); // { dg-error "" }
five sink_4_4567( A&&); // { dg-error "" }
six sink_4_4567(const A&&); // { dg-error "" }
seven sink_4_4567(volatile A&&); // { dg-error "" }
int test4_4567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_4567(cv_source()); // { dg-error "no match" }
return 0;
}
four sink_4_4678(const volatile A&);
six sink_4_4678(const A&&); // { dg-error "" }
seven sink_4_4678(volatile A&&); // { dg-error "" }
eight sink_4_4678(const volatile A&&); // { dg-error "" }
int test4_4678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_4_4678(source()); // { dg-error "ambiguous" }
return 0;
}
int main()
{
return test4_1235() + test4_1236() + test4_1237() + test4_1256() + test4_1257() +
test4_1267() + test4_1356() + test4_1357() + test4_1467() + test4_1567() +
test4_1678() + test4_2345() + test4_2346() + test4_2347() + test4_2348() +
test4_2356() + test4_2357() + test4_2358() + test4_2367() + test4_2368() +
test4_2378() + test4_2467() + test4_2567() + test4_2678() + test4_3467() +
test4_3567() + test4_3678() + test4_4678();
}

1497
gcc/testsuite/g++.dg/cpp0x/rv4p.C Normal file
View file

File diff suppressed because it is too large Load diff

575
gcc/testsuite/g++.dg/cpp0x/rv5n.C Normal file
View file

@ -0,0 +1,575 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 5 at a time
one sink_5_12345( A&); // { dg-error "" }
two sink_5_12345(const A&); // { dg-error "" }
three sink_5_12345(volatile A&); // { dg-error "" }
four sink_5_12345(const volatile A&); // { dg-error "" }
five sink_5_12345( A&&); // { dg-error "" }
int test5_12345()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12345(v_source()); // { dg-error "no match" }
sink_5_12345(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12346( A&); // { dg-error "" }
two sink_5_12346(const A&); // { dg-error "" }
three sink_5_12346(volatile A&); // { dg-error "" }
four sink_5_12346(const volatile A&); // { dg-error "" }
six sink_5_12346(const A&&); // { dg-error "" }
int test5_12346()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12346(v_source()); // { dg-error "no match" }
sink_5_12346(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12347( A&); // { dg-error "" }
two sink_5_12347(const A&); // { dg-error "" }
three sink_5_12347(volatile A&); // { dg-error "" }
four sink_5_12347(const volatile A&); // { dg-error "" }
seven sink_5_12347(volatile A&&); // { dg-error "" }
int test5_12347()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12347(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12356( A&); // { dg-error "" }
two sink_5_12356(const A&); // { dg-error "" }
three sink_5_12356(volatile A&); // { dg-error "" }
five sink_5_12356( A&&); // { dg-error "" }
six sink_5_12356(const A&&); // { dg-error "" }
int test5_12356()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12356(cva); // { dg-error "no match" }
sink_5_12356(v_source()); // { dg-error "no match" }
sink_5_12356(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12357( A&); // { dg-error "" }
two sink_5_12357(const A&); // { dg-error "" }
three sink_5_12357(volatile A&); // { dg-error "" }
five sink_5_12357( A&&); // { dg-error "" }
seven sink_5_12357(volatile A&&); // { dg-error "" }
int test5_12357()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12357(cva); // { dg-error "no match" }
sink_5_12357(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12367( A&); // { dg-error "" }
two sink_5_12367(const A&); // { dg-error "" }
three sink_5_12367(volatile A&); // { dg-error "" }
six sink_5_12367(const A&&); // { dg-error "" }
seven sink_5_12367(volatile A&&); // { dg-error "" }
int test5_12367()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12367(cva); // { dg-error "no match" }
sink_5_12367(source()); // { dg-error "ambiguous" }
sink_5_12367(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12456( A&); // { dg-error "" }
two sink_5_12456(const A&); // { dg-error "" }
four sink_5_12456(const volatile A&); // { dg-error "" }
five sink_5_12456( A&&); // { dg-error "" }
six sink_5_12456(const A&&); // { dg-error "" }
int test5_12456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12456(v_source()); // { dg-error "no match" }
sink_5_12456(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12457( A&); // { dg-error "" }
two sink_5_12457(const A&); // { dg-error "" }
four sink_5_12457(const volatile A&); // { dg-error "" }
five sink_5_12457( A&&); // { dg-error "" }
seven sink_5_12457(volatile A&&); // { dg-error "" }
int test5_12457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12457(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12467( A&); // { dg-error "" }
two sink_5_12467(const A&); // { dg-error "" }
four sink_5_12467(const volatile A&); // { dg-error "" }
six sink_5_12467(const A&&); // { dg-error "" }
seven sink_5_12467(volatile A&&); // { dg-error "" }
int test5_12467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12467(source()); // { dg-error "ambiguous" }
sink_5_12467(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12567( A&); // { dg-error "" }
two sink_5_12567(const A&); // { dg-error "" }
five sink_5_12567( A&&); // { dg-error "" }
six sink_5_12567(const A&&); // { dg-error "" }
seven sink_5_12567(volatile A&&); // { dg-error "" }
int test5_12567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12567(cva); // { dg-error "no match" }
sink_5_12567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_12678( A&);
two sink_5_12678(const A&); // { dg-error "" }
six sink_5_12678(const A&&); // { dg-error "" }
seven sink_5_12678(volatile A&&); // { dg-error "" }
eight sink_5_12678(const volatile A&&); // { dg-error "" }
int test5_12678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_12678(source()); // { dg-error "ambiguous" }
return 0;
}
one sink_5_13456( A&); // { dg-error "" }
three sink_5_13456(volatile A&); // { dg-error "" }
four sink_5_13456(const volatile A&); // { dg-error "" }
five sink_5_13456( A&&); // { dg-error "" }
six sink_5_13456(const A&&); // { dg-error "" }
int test5_13456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_13456(v_source()); // { dg-error "no match" }
sink_5_13456(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_13457( A&); // { dg-error "" }
three sink_5_13457(volatile A&); // { dg-error "" }
four sink_5_13457(const volatile A&); // { dg-error "" }
five sink_5_13457( A&&); // { dg-error "" }
seven sink_5_13457(volatile A&&); // { dg-error "" }
int test5_13457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_13457(c_source()); // { dg-error "no match" }
sink_5_13457(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_13467( A&); // { dg-error "" }
three sink_5_13467(volatile A&); // { dg-error "" }
four sink_5_13467(const volatile A&); // { dg-error "" }
six sink_5_13467(const A&&); // { dg-error "" }
seven sink_5_13467(volatile A&&); // { dg-error "" }
int test5_13467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_13467(source()); // { dg-error "ambiguous" }
sink_5_13467(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_13567( A&); // { dg-error "" }
three sink_5_13567(volatile A&); // { dg-error "" }
five sink_5_13567( A&&); // { dg-error "" }
six sink_5_13567(const A&&); // { dg-error "" }
seven sink_5_13567(volatile A&&); // { dg-error "" }
int test5_13567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_13567(cva); // { dg-error "no match" }
sink_5_13567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_13678( A&);
three sink_5_13678(volatile A&);
six sink_5_13678(const A&&); // { dg-error "" }
seven sink_5_13678(volatile A&&); // { dg-error "" }
eight sink_5_13678(const volatile A&&); // { dg-error "" }
int test5_13678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_13678(source()); // { dg-error "ambiguous" }
return 0;
}
one sink_5_14567( A&); // { dg-error "" }
four sink_5_14567(const volatile A&); // { dg-error "" }
five sink_5_14567( A&&); // { dg-error "" }
six sink_5_14567(const A&&); // { dg-error "" }
seven sink_5_14567(volatile A&&); // { dg-error "" }
int test5_14567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_14567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_5_14678( A&);
four sink_5_14678(const volatile A&);
six sink_5_14678(const A&&); // { dg-error "" }
seven sink_5_14678(volatile A&&); // { dg-error "" }
eight sink_5_14678(const volatile A&&); // { dg-error "" }
int test5_14678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_14678(source()); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23456(const A&); // { dg-error "" }
three sink_5_23456(volatile A&); // { dg-error "" }
four sink_5_23456(const volatile A&); // { dg-error "" }
five sink_5_23456( A&&); // { dg-error "" }
six sink_5_23456(const A&&); // { dg-error "" }
int test5_23456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23456(a); // { dg-error "ambiguous" }
sink_5_23456(v_source()); // { dg-error "no match" }
sink_5_23456(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_5_23457(const A&); // { dg-error "" }
three sink_5_23457(volatile A&); // { dg-error "" }
four sink_5_23457(const volatile A&); // { dg-error "" }
five sink_5_23457( A&&); // { dg-error "" }
seven sink_5_23457(volatile A&&); // { dg-error "" }
int test5_23457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23457(a); // { dg-error "ambiguous" }
sink_5_23457(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_5_23458(const A&); // { dg-error "" }
three sink_5_23458(volatile A&); // { dg-error "" }
four sink_5_23458(const volatile A&); // { dg-error "" }
five sink_5_23458( A&&); // { dg-error "" }
eight sink_5_23458(const volatile A&&); // { dg-error "" }
int test5_23458()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23458(a); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23467(const A&); // { dg-error "" }
three sink_5_23467(volatile A&); // { dg-error "" }
four sink_5_23467(const volatile A&); // { dg-error "" }
six sink_5_23467(const A&&); // { dg-error "" }
seven sink_5_23467(volatile A&&); // { dg-error "" }
int test5_23467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23467(a); // { dg-error "ambiguous" }
sink_5_23467(source()); // { dg-error "ambiguous" }
sink_5_23467(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_5_23468(const A&); // { dg-error "" }
three sink_5_23468(volatile A&); // { dg-error "" }
four sink_5_23468(const volatile A&); // { dg-error "" }
six sink_5_23468(const A&&); // { dg-error "" }
eight sink_5_23468(const volatile A&&); // { dg-error "" }
int test5_23468()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23468(a); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23478(const A&); // { dg-error "" }
three sink_5_23478(volatile A&); // { dg-error "" }
four sink_5_23478(const volatile A&); // { dg-error "" }
seven sink_5_23478(volatile A&&); // { dg-error "" }
eight sink_5_23478(const volatile A&&); // { dg-error "" }
int test5_23478()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23478(a); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23567(const A&); // { dg-error "" }
three sink_5_23567(volatile A&); // { dg-error "" }
five sink_5_23567( A&&); // { dg-error "" }
six sink_5_23567(const A&&); // { dg-error "" }
seven sink_5_23567(volatile A&&); // { dg-error "" }
int test5_23567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23567(a); // { dg-error "ambiguous" }
sink_5_23567(cva); // { dg-error "no match" }
sink_5_23567(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_5_23568(const A&); // { dg-error "" }
three sink_5_23568(volatile A&); // { dg-error "" }
five sink_5_23568( A&&); // { dg-error "" }
six sink_5_23568(const A&&); // { dg-error "" }
eight sink_5_23568(const volatile A&&); // { dg-error "" }
int test5_23568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23568(a); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23578(const A&); // { dg-error "" }
three sink_5_23578(volatile A&); // { dg-error "" }
five sink_5_23578( A&&); // { dg-error "" }
seven sink_5_23578(volatile A&&); // { dg-error "" }
eight sink_5_23578(const volatile A&&); // { dg-error "" }
int test5_23578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23578(a); // { dg-error "ambiguous" }
return 0;
}
two sink_5_23678(const A&); // { dg-error "" }
three sink_5_23678(volatile A&); // { dg-error "" }
six sink_5_23678(const A&&); // { dg-error "" }
seven sink_5_23678(volatile A&&); // { dg-error "" }
eight sink_5_23678(const volatile A&&); // { dg-error "" }
int test5_23678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_23678(a); // { dg-error "ambiguous" }
sink_5_23678(source()); // { dg-error "ambiguous" }
return 0;
}
two sink_5_24567(const A&); // { dg-error "" }
four sink_5_24567(const volatile A&); // { dg-error "" }
five sink_5_24567( A&&); // { dg-error "" }
six sink_5_24567(const A&&); // { dg-error "" }
seven sink_5_24567(volatile A&&); // { dg-error "" }
int test5_24567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_24567(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_5_24678(const A&); // { dg-error "" }
four sink_5_24678(const volatile A&);
six sink_5_24678(const A&&); // { dg-error "" }
seven sink_5_24678(volatile A&&); // { dg-error "" }
eight sink_5_24678(const volatile A&&); // { dg-error "" }
int test5_24678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_24678(source()); // { dg-error "ambiguous" }
return 0;
}
three sink_5_34567(volatile A&); // { dg-error "" }
four sink_5_34567(const volatile A&); // { dg-error "" }
five sink_5_34567( A&&); // { dg-error "" }
six sink_5_34567(const A&&); // { dg-error "" }
seven sink_5_34567(volatile A&&); // { dg-error "" }
int test5_34567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_34567(cv_source()); // { dg-error "no match" }
return 0;
}
three sink_5_34678(volatile A&);
four sink_5_34678(const volatile A&);
six sink_5_34678(const A&&); // { dg-error "" }
seven sink_5_34678(volatile A&&); // { dg-error "" }
eight sink_5_34678(const volatile A&&); // { dg-error "" }
int test5_34678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_5_34678(source()); // { dg-error "ambiguous" }
return 0;
}
int main()
{
return test5_12356() + test5_12357() + test5_12367() + test5_12467() +
test5_12567() + test5_12678() + test5_13467() + test5_13567() +
test5_13678() + test5_13678() + test5_23456() + test5_23457() +
test5_23458() + test5_23467() + test5_23468() + test5_23478() +
test5_23567() + test5_23568() + test5_23578() + test5_23678() +
test5_24678() + test5_34678();
}

1283
gcc/testsuite/g++.dg/cpp0x/rv5p.C Normal file
View file

File diff suppressed because it is too large Load diff

281
gcc/testsuite/g++.dg/cpp0x/rv6n.C Normal file
View file

@ -0,0 +1,281 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 6 at a time
one sink_6_123456( A&); // { dg-error "" }
two sink_6_123456(const A&); // { dg-error "" }
three sink_6_123456(volatile A&); // { dg-error "" }
four sink_6_123456(const volatile A&); // { dg-error "" }
five sink_6_123456( A&&); // { dg-error "" }
six sink_6_123456(const A&&); // { dg-error "" }
int test6_123456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_123456(v_source()); // { dg-error "no match" }
sink_6_123456(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_6_123457( A&); // { dg-error "" }
two sink_6_123457(const A&); // { dg-error "" }
three sink_6_123457(volatile A&); // { dg-error "" }
four sink_6_123457(const volatile A&); // { dg-error "" }
five sink_6_123457( A&&); // { dg-error "" }
seven sink_6_123457(volatile A&&); // { dg-error "" }
int test6_123457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_123457(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_6_235678(const A&); // { dg-error "" }
three sink_6_235678(volatile A&); // { dg-error "" }
five sink_6_235678( A&&); // { dg-error "" }
six sink_6_235678(const A&&); // { dg-error "" }
seven sink_6_235678(volatile A&&); // { dg-error "" }
eight sink_6_235678(const volatile A&&); // { dg-error "" }
int test6_235678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_235678(a); // { dg-error "ambiguous" }
return 0;
}
two sink_6_234678(const A&); // { dg-error "" }
three sink_6_234678(volatile A&); // { dg-error "" }
four sink_6_234678(const volatile A&); // { dg-error "" }
six sink_6_234678(const A&&); // { dg-error "" }
seven sink_6_234678(volatile A&&); // { dg-error "" }
eight sink_6_234678(const volatile A&&); // { dg-error "" }
int test6_234678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_234678(a); // { dg-error "ambiguous" }
sink_6_234678(source()); // { dg-error "ambiguous" }
return 0;
}
two sink_6_234578(const A&); // { dg-error "" }
three sink_6_234578(volatile A&); // { dg-error "" }
four sink_6_234578(const volatile A&); // { dg-error "" }
five sink_6_234578( A&&); // { dg-error "" }
seven sink_6_234578(volatile A&&); // { dg-error "" }
eight sink_6_234578(const volatile A&&); // { dg-error "" }
int test6_234578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_234578(a); // { dg-error "ambiguous" }
return 0;
}
two sink_6_234568(const A&); // { dg-error "" }
three sink_6_234568(volatile A&); // { dg-error "" }
four sink_6_234568(const volatile A&); // { dg-error "" }
five sink_6_234568( A&&); // { dg-error "" }
six sink_6_234568(const A&&); // { dg-error "" }
eight sink_6_234568(const volatile A&&); // { dg-error "" }
int test6_234568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_234568(a); // { dg-error "ambiguous" }
return 0;
}
two sink_6_234567(const A&); // { dg-error "" }
three sink_6_234567(volatile A&); // { dg-error "" }
four sink_6_234567(const volatile A&); // { dg-error "" }
five sink_6_234567( A&&); // { dg-error "" }
six sink_6_234567(const A&&); // { dg-error "" }
seven sink_6_234567(volatile A&&); // { dg-error "" }
int test6_234567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_234567(a); // { dg-error "ambiguous" }
sink_6_234567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_6_134678( A&);
three sink_6_134678(volatile A&);
four sink_6_134678(const volatile A&);
six sink_6_134678(const A&&); // { dg-error "" }
seven sink_6_134678(volatile A&&); // { dg-error "" }
eight sink_6_134678(const volatile A&&); // { dg-error "" }
int test6_134678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_134678(source()); // { dg-error "ambiguous" }
return 0;
}
one sink_6_124678( A&);
two sink_6_124678(const A&); // { dg-error "" }
four sink_6_124678(const volatile A&);
six sink_6_124678(const A&&); // { dg-error "" }
seven sink_6_124678(volatile A&&); // { dg-error "" }
eight sink_6_124678(const volatile A&&); // { dg-error "" }
int test6_124678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_124678(source()); // { dg-error "ambiguous" }
return 0;
}
one sink_6_123678( A&);
two sink_6_123678(const A&); // { dg-error "" }
three sink_6_123678(volatile A&);
six sink_6_123678(const A&&); // { dg-error "" }
seven sink_6_123678(volatile A&&); // { dg-error "" }
eight sink_6_123678(const volatile A&&); // { dg-error "" }
int test6_123678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_123678(source()); // { dg-error "ambiguous" }
return 0;
}
one sink_6_123567( A&); // { dg-error "" }
two sink_6_123567(const A&); // { dg-error "" }
three sink_6_123567(volatile A&); // { dg-error "" }
five sink_6_123567( A&&); // { dg-error "" }
six sink_6_123567(const A&&); // { dg-error "" }
seven sink_6_123567(volatile A&&); // { dg-error "" }
int test6_123567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_123567(cva); // { dg-error "no match" }
sink_6_123567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_6_123467( A&); // { dg-error "" }
two sink_6_123467(const A&); // { dg-error "" }
three sink_6_123467(volatile A&); // { dg-error "" }
four sink_6_123467(const volatile A&); // { dg-error "" }
six sink_6_123467(const A&&); // { dg-error "" }
seven sink_6_123467(volatile A&&); // { dg-error "" }
int test6_123467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_123467(source()); // { dg-error "ambiguous" }
sink_6_123467(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_6_124567( A&); // { dg-error "" }
two sink_6_124567(const A&); // { dg-error "" }
four sink_6_124567(const volatile A&); // { dg-error "" }
five sink_6_124567( A&&); // { dg-error "" }
six sink_6_124567(const A&&); // { dg-error "" }
seven sink_6_124567(volatile A&&); // { dg-error "" }
int test6_124567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_124567(cv_source()); // { dg-error "no match" }
return 0;
}
one sink_6_134567( A&); // { dg-error "" }
three sink_6_134567(volatile A&); // { dg-error "" }
four sink_6_134567(const volatile A&); // { dg-error "" }
five sink_6_134567( A&&); // { dg-error "" }
six sink_6_134567(const A&&); // { dg-error "" }
seven sink_6_134567(volatile A&&); // { dg-error "" }
int test6_134567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_6_134567(cv_source()); // { dg-error "no match" }
return 0;
}
int main()
{
return test6_235678() + test6_234678() + test6_234578() + test6_234568() +
test6_234567() + test6_134678() + test6_124678() + test6_123678() +
test6_123567();
}

695
gcc/testsuite/g++.dg/cpp0x/rv6p.C Normal file
View file

@ -0,0 +1,695 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 6 at a time
one sink_6_123456( A&);
two sink_6_123456(const A&);
three sink_6_123456(volatile A&);
four sink_6_123456(const volatile A&);
five sink_6_123456( A&&);
six sink_6_123456(const A&&);
int test6_123456()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123456(a)) == 1> t1;
sa<sizeof(sink_6_123456(ca)) == 2> t2;
sa<sizeof(sink_6_123456(va)) == 3> t3;
sa<sizeof(sink_6_123456(cva)) == 4> t4;
sa<sizeof(sink_6_123456(source())) == 5> t5;
sa<sizeof(sink_6_123456(c_source())) == 6> t6;
return 0;
}
one sink_6_123457( A&);
two sink_6_123457(const A&);
three sink_6_123457(volatile A&);
four sink_6_123457(const volatile A&);
five sink_6_123457( A&&);
seven sink_6_123457(volatile A&&);
int test6_123457()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123457(a)) == 1> t1;
sa<sizeof(sink_6_123457(ca)) == 2> t2;
sa<sizeof(sink_6_123457(va)) == 3> t3;
sa<sizeof(sink_6_123457(cva)) == 4> t4;
sa<sizeof(sink_6_123457(source())) == 5> t5;
sa<sizeof(sink_6_123457(c_source())) == 2> t6;
sa<sizeof(sink_6_123457(v_source())) == 7> t7;
return 0;
}
one sink_6_123458( A&);
two sink_6_123458(const A&);
three sink_6_123458(volatile A&);
four sink_6_123458(const volatile A&);
five sink_6_123458( A&&);
eight sink_6_123458(const volatile A&&);
int test6_123458()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123458(a)) == 1> t1;
sa<sizeof(sink_6_123458(ca)) == 2> t2;
sa<sizeof(sink_6_123458(va)) == 3> t3;
sa<sizeof(sink_6_123458(cva)) == 4> t4;
sa<sizeof(sink_6_123458(source())) == 5> t5;
sa<sizeof(sink_6_123458(c_source())) == 8> t6;
sa<sizeof(sink_6_123458(v_source())) == 8> t7;
sa<sizeof(sink_6_123458(cv_source())) == 8> t8;
return 0;
}
one sink_6_123467( A&);
two sink_6_123467(const A&);
three sink_6_123467(volatile A&);
four sink_6_123467(const volatile A&);
six sink_6_123467(const A&&);
seven sink_6_123467(volatile A&&);
int test6_123467()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123467(a)) == 1> t1;
sa<sizeof(sink_6_123467(ca)) == 2> t2;
sa<sizeof(sink_6_123467(va)) == 3> t3;
sa<sizeof(sink_6_123467(cva)) == 4> t4;
sa<sizeof(sink_6_123467(c_source())) == 6> t6;
sa<sizeof(sink_6_123467(v_source())) == 7> t7;
return 0;
}
one sink_6_123468( A&);
two sink_6_123468(const A&);
three sink_6_123468(volatile A&);
four sink_6_123468(const volatile A&);
six sink_6_123468(const A&&);
eight sink_6_123468(const volatile A&&);
int test6_123468()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123468(a)) == 1> t1;
sa<sizeof(sink_6_123468(ca)) == 2> t2;
sa<sizeof(sink_6_123468(va)) == 3> t3;
sa<sizeof(sink_6_123468(cva)) == 4> t4;
sa<sizeof(sink_6_123468(source())) == 6> t5;
sa<sizeof(sink_6_123468(c_source())) == 6> t6;
sa<sizeof(sink_6_123468(v_source())) == 8> t7;
sa<sizeof(sink_6_123468(cv_source())) == 8> t8;
return 0;
}
one sink_6_123478( A&);
two sink_6_123478(const A&);
three sink_6_123478(volatile A&);
four sink_6_123478(const volatile A&);
seven sink_6_123478(volatile A&&);
eight sink_6_123478(const volatile A&&);
int test6_123478()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123478(a)) == 1> t1;
sa<sizeof(sink_6_123478(ca)) == 2> t2;
sa<sizeof(sink_6_123478(va)) == 3> t3;
sa<sizeof(sink_6_123478(cva)) == 4> t4;
sa<sizeof(sink_6_123478(source())) == 7> t5;
sa<sizeof(sink_6_123478(c_source())) == 8> t6;
sa<sizeof(sink_6_123478(v_source())) == 7> t7;
sa<sizeof(sink_6_123478(cv_source())) == 8> t8;
return 0;
}
one sink_6_123567( A&);
two sink_6_123567(const A&);
three sink_6_123567(volatile A&);
five sink_6_123567( A&&);
six sink_6_123567(const A&&);
seven sink_6_123567(volatile A&&);
int test6_123567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123567(a)) == 1> t1;
sa<sizeof(sink_6_123567(ca)) == 2> t2;
sa<sizeof(sink_6_123567(va)) == 3> t3;
sa<sizeof(sink_6_123567(source())) == 5> t5;
sa<sizeof(sink_6_123567(c_source())) == 6> t6;
sa<sizeof(sink_6_123567(v_source())) == 7> t7;
return 0;
}
one sink_6_123568( A&);
two sink_6_123568(const A&);
three sink_6_123568(volatile A&);
five sink_6_123568( A&&);
six sink_6_123568(const A&&);
eight sink_6_123568(const volatile A&&);
int test6_123568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123568(a)) == 1> t1;
sa<sizeof(sink_6_123568(ca)) == 2> t2;
sa<sizeof(sink_6_123568(va)) == 3> t3;
sa<sizeof(sink_6_123568(cva)) == 8> t4;
sa<sizeof(sink_6_123568(source())) == 5> t5;
sa<sizeof(sink_6_123568(c_source())) == 6> t6;
sa<sizeof(sink_6_123568(v_source())) == 8> t7;
sa<sizeof(sink_6_123568(cv_source())) == 8> t8;
return 0;
}
one sink_6_123578( A&);
two sink_6_123578(const A&);
three sink_6_123578(volatile A&);
five sink_6_123578( A&&);
seven sink_6_123578(volatile A&&);
eight sink_6_123578(const volatile A&&);
int test6_123578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123578(a)) == 1> t1;
sa<sizeof(sink_6_123578(ca)) == 2> t2;
sa<sizeof(sink_6_123578(va)) == 3> t3;
sa<sizeof(sink_6_123578(cva)) == 8> t4;
sa<sizeof(sink_6_123578(source())) == 5> t5;
sa<sizeof(sink_6_123578(c_source())) == 8> t6;
sa<sizeof(sink_6_123578(v_source())) == 7> t7;
sa<sizeof(sink_6_123578(cv_source())) == 8> t8;
return 0;
}
one sink_6_123678( A&);
two sink_6_123678(const A&);
three sink_6_123678(volatile A&);
six sink_6_123678(const A&&);
seven sink_6_123678(volatile A&&);
eight sink_6_123678(const volatile A&&);
int test6_123678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_123678(a)) == 1> t1;
sa<sizeof(sink_6_123678(ca)) == 2> t2;
sa<sizeof(sink_6_123678(va)) == 3> t3;
sa<sizeof(sink_6_123678(cva)) == 8> t4;
sa<sizeof(sink_6_123678(c_source())) == 6> t6;
sa<sizeof(sink_6_123678(v_source())) == 7> t7;
sa<sizeof(sink_6_123678(cv_source())) == 8> t8;
return 0;
}
one sink_6_124567( A&);
two sink_6_124567(const A&);
four sink_6_124567(const volatile A&);
five sink_6_124567( A&&);
six sink_6_124567(const A&&);
seven sink_6_124567(volatile A&&);
int test6_124567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_124567(a)) == 1> t1;
sa<sizeof(sink_6_124567(ca)) == 2> t2;
sa<sizeof(sink_6_124567(va)) == 4> t3;
sa<sizeof(sink_6_124567(cva)) == 4> t4;
sa<sizeof(sink_6_124567(source())) == 5> t5;
sa<sizeof(sink_6_124567(c_source())) == 6> t6;
sa<sizeof(sink_6_124567(v_source())) == 7> t7;
return 0;
}
one sink_6_124568( A&);
two sink_6_124568(const A&);
four sink_6_124568(const volatile A&);
five sink_6_124568( A&&);
six sink_6_124568(const A&&);
eight sink_6_124568(const volatile A&&);
int test6_124568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_124568(a)) == 1> t1;
sa<sizeof(sink_6_124568(ca)) == 2> t2;
sa<sizeof(sink_6_124568(va)) == 4> t3;
sa<sizeof(sink_6_124568(cva)) == 4> t4;
sa<sizeof(sink_6_124568(source())) == 5> t5;
sa<sizeof(sink_6_124568(c_source())) == 6> t6;
sa<sizeof(sink_6_124568(v_source())) == 8> t7;
sa<sizeof(sink_6_124568(cv_source())) == 8> t8;
return 0;
}
one sink_6_124578( A&);
two sink_6_124578(const A&);
four sink_6_124578(const volatile A&);
five sink_6_124578( A&&);
seven sink_6_124578(volatile A&&);
eight sink_6_124578(const volatile A&&);
int test6_124578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_124578(a)) == 1> t1;
sa<sizeof(sink_6_124578(ca)) == 2> t2;
sa<sizeof(sink_6_124578(va)) == 4> t3;
sa<sizeof(sink_6_124578(cva)) == 4> t4;
sa<sizeof(sink_6_124578(source())) == 5> t5;
sa<sizeof(sink_6_124578(c_source())) == 8> t6;
sa<sizeof(sink_6_124578(v_source())) == 7> t7;
sa<sizeof(sink_6_124578(cv_source())) == 8> t8;
return 0;
}
one sink_6_124678( A&);
two sink_6_124678(const A&);
four sink_6_124678(const volatile A&);
six sink_6_124678(const A&&);
seven sink_6_124678(volatile A&&);
eight sink_6_124678(const volatile A&&);
int test6_124678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_124678(a)) == 1> t1;
sa<sizeof(sink_6_124678(ca)) == 2> t2;
sa<sizeof(sink_6_124678(va)) == 4> t3;
sa<sizeof(sink_6_124678(cva)) == 4> t4;
sa<sizeof(sink_6_124678(c_source())) == 6> t6;
sa<sizeof(sink_6_124678(v_source())) == 7> t7;
sa<sizeof(sink_6_124678(cv_source())) == 8> t8;
return 0;
}
one sink_6_125678( A&);
two sink_6_125678(const A&);
five sink_6_125678( A&&);
six sink_6_125678(const A&&);
seven sink_6_125678(volatile A&&);
eight sink_6_125678(const volatile A&&);
int test6_125678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_125678(a)) == 1> t1;
sa<sizeof(sink_6_125678(ca)) == 2> t2;
sa<sizeof(sink_6_125678(va)) == 7> t3;
sa<sizeof(sink_6_125678(cva)) == 8> t4;
sa<sizeof(sink_6_125678(source())) == 5> t5;
sa<sizeof(sink_6_125678(c_source())) == 6> t6;
sa<sizeof(sink_6_125678(v_source())) == 7> t7;
sa<sizeof(sink_6_125678(cv_source())) == 8> t8;
return 0;
}
one sink_6_134567( A&);
three sink_6_134567(volatile A&);
four sink_6_134567(const volatile A&);
five sink_6_134567( A&&);
six sink_6_134567(const A&&);
seven sink_6_134567(volatile A&&);
int test6_134567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_134567(a)) == 1> t1;
sa<sizeof(sink_6_134567(ca)) == 4> t2;
sa<sizeof(sink_6_134567(va)) == 3> t3;
sa<sizeof(sink_6_134567(cva)) == 4> t4;
sa<sizeof(sink_6_134567(source())) == 5> t5;
sa<sizeof(sink_6_134567(c_source())) == 6> t6;
sa<sizeof(sink_6_134567(v_source())) == 7> t7;
return 0;
}
one sink_6_134568( A&);
three sink_6_134568(volatile A&);
four sink_6_134568(const volatile A&);
five sink_6_134568( A&&);
six sink_6_134568(const A&&);
eight sink_6_134568(const volatile A&&);
int test6_134568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_134568(a)) == 1> t1;
sa<sizeof(sink_6_134568(ca)) == 4> t2;
sa<sizeof(sink_6_134568(va)) == 3> t3;
sa<sizeof(sink_6_134568(cva)) == 4> t4;
sa<sizeof(sink_6_134568(source())) == 5> t5;
sa<sizeof(sink_6_134568(c_source())) == 6> t6;
sa<sizeof(sink_6_134568(v_source())) == 8> t7;
sa<sizeof(sink_6_134568(cv_source())) == 8> t8;
return 0;
}
one sink_6_134578( A&);
three sink_6_134578(volatile A&);
four sink_6_134578(const volatile A&);
five sink_6_134578( A&&);
seven sink_6_134578(volatile A&&);
eight sink_6_134578(const volatile A&&);
int test6_134578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_134578(a)) == 1> t1;
sa<sizeof(sink_6_134578(ca)) == 4> t2;
sa<sizeof(sink_6_134578(va)) == 3> t3;
sa<sizeof(sink_6_134578(cva)) == 4> t4;
sa<sizeof(sink_6_134578(source())) == 5> t5;
sa<sizeof(sink_6_134578(c_source())) == 8> t6;
sa<sizeof(sink_6_134578(v_source())) == 7> t7;
sa<sizeof(sink_6_134578(cv_source())) == 8> t8;
return 0;
}
one sink_6_134678( A&);
three sink_6_134678(volatile A&);
four sink_6_134678(const volatile A&);
six sink_6_134678(const A&&);
seven sink_6_134678(volatile A&&);
eight sink_6_134678(const volatile A&&);
int test6_134678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_134678(a)) == 1> t1;
sa<sizeof(sink_6_134678(ca)) == 4> t2;
sa<sizeof(sink_6_134678(va)) == 3> t3;
sa<sizeof(sink_6_134678(cva)) == 4> t4;
sa<sizeof(sink_6_134678(c_source())) == 6> t6;
sa<sizeof(sink_6_134678(v_source())) == 7> t7;
sa<sizeof(sink_6_134678(cv_source())) == 8> t8;
return 0;
}
one sink_6_135678( A&);
three sink_6_135678(volatile A&);
five sink_6_135678( A&&);
six sink_6_135678(const A&&);
seven sink_6_135678(volatile A&&);
eight sink_6_135678(const volatile A&&);
int test6_135678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_135678(a)) == 1> t1;
sa<sizeof(sink_6_135678(ca)) == 6> t2;
sa<sizeof(sink_6_135678(va)) == 3> t3;
sa<sizeof(sink_6_135678(cva)) == 8> t4;
sa<sizeof(sink_6_135678(source())) == 5> t5;
sa<sizeof(sink_6_135678(c_source())) == 6> t6;
sa<sizeof(sink_6_135678(v_source())) == 7> t7;
sa<sizeof(sink_6_135678(cv_source())) == 8> t8;
return 0;
}
one sink_6_145678( A&);
four sink_6_145678(const volatile A&);
five sink_6_145678( A&&);
six sink_6_145678(const A&&);
seven sink_6_145678(volatile A&&);
eight sink_6_145678(const volatile A&&);
int test6_145678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_145678(a)) == 1> t1;
sa<sizeof(sink_6_145678(ca)) == 4> t2;
sa<sizeof(sink_6_145678(va)) == 4> t3;
sa<sizeof(sink_6_145678(cva)) == 4> t4;
sa<sizeof(sink_6_145678(source())) == 5> t5;
sa<sizeof(sink_6_145678(c_source())) == 6> t6;
sa<sizeof(sink_6_145678(v_source())) == 7> t7;
sa<sizeof(sink_6_145678(cv_source())) == 8> t8;
return 0;
}
two sink_6_234567(const A&);
three sink_6_234567(volatile A&);
four sink_6_234567(const volatile A&);
five sink_6_234567( A&&);
six sink_6_234567(const A&&);
seven sink_6_234567(volatile A&&);
int test6_234567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_234567(ca)) == 2> t2;
sa<sizeof(sink_6_234567(va)) == 3> t3;
sa<sizeof(sink_6_234567(cva)) == 4> t4;
sa<sizeof(sink_6_234567(source())) == 5> t5;
sa<sizeof(sink_6_234567(c_source())) == 6> t6;
sa<sizeof(sink_6_234567(v_source())) == 7> t7;
return 0;
}
two sink_6_234568(const A&);
three sink_6_234568(volatile A&);
four sink_6_234568(const volatile A&);
five sink_6_234568( A&&);
six sink_6_234568(const A&&);
eight sink_6_234568(const volatile A&&);
int test6_234568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_234568(ca)) == 2> t2;
sa<sizeof(sink_6_234568(va)) == 3> t3;
sa<sizeof(sink_6_234568(cva)) == 4> t4;
sa<sizeof(sink_6_234568(source())) == 5> t5;
sa<sizeof(sink_6_234568(c_source())) == 6> t6;
sa<sizeof(sink_6_234568(v_source())) == 8> t7;
sa<sizeof(sink_6_234568(cv_source())) == 8> t8;
return 0;
}
two sink_6_234578(const A&);
three sink_6_234578(volatile A&);
four sink_6_234578(const volatile A&);
five sink_6_234578( A&&);
seven sink_6_234578(volatile A&&);
eight sink_6_234578(const volatile A&&);
int test6_234578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_234578(ca)) == 2> t2;
sa<sizeof(sink_6_234578(va)) == 3> t3;
sa<sizeof(sink_6_234578(cva)) == 4> t4;
sa<sizeof(sink_6_234578(source())) == 5> t5;
sa<sizeof(sink_6_234578(c_source())) == 8> t6;
sa<sizeof(sink_6_234578(v_source())) == 7> t7;
sa<sizeof(sink_6_234578(cv_source())) == 8> t8;
return 0;
}
two sink_6_234678(const A&);
three sink_6_234678(volatile A&);
four sink_6_234678(const volatile A&);
six sink_6_234678(const A&&);
seven sink_6_234678(volatile A&&);
eight sink_6_234678(const volatile A&&);
int test6_234678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_234678(ca)) == 2> t2;
sa<sizeof(sink_6_234678(va)) == 3> t3;
sa<sizeof(sink_6_234678(cva)) == 4> t4;
sa<sizeof(sink_6_234678(c_source())) == 6> t6;
sa<sizeof(sink_6_234678(v_source())) == 7> t7;
sa<sizeof(sink_6_234678(cv_source())) == 8> t8;
return 0;
}
two sink_6_235678(const A&);
three sink_6_235678(volatile A&);
five sink_6_235678( A&&);
six sink_6_235678(const A&&);
seven sink_6_235678(volatile A&&);
eight sink_6_235678(const volatile A&&);
int test6_235678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_235678(ca)) == 2> t2;
sa<sizeof(sink_6_235678(va)) == 3> t3;
sa<sizeof(sink_6_235678(cva)) == 8> t4;
sa<sizeof(sink_6_235678(source())) == 5> t5;
sa<sizeof(sink_6_235678(c_source())) == 6> t6;
sa<sizeof(sink_6_235678(v_source())) == 7> t7;
sa<sizeof(sink_6_235678(cv_source())) == 8> t8;
return 0;
}
two sink_6_245678(const A&);
four sink_6_245678(const volatile A&);
five sink_6_245678( A&&);
six sink_6_245678(const A&&);
seven sink_6_245678(volatile A&&);
eight sink_6_245678(const volatile A&&);
int test6_245678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_245678(a)) == 2> t1;
sa<sizeof(sink_6_245678(ca)) == 2> t2;
sa<sizeof(sink_6_245678(va)) == 4> t3;
sa<sizeof(sink_6_245678(cva)) == 4> t4;
sa<sizeof(sink_6_245678(source())) == 5> t5;
sa<sizeof(sink_6_245678(c_source())) == 6> t6;
sa<sizeof(sink_6_245678(v_source())) == 7> t7;
sa<sizeof(sink_6_245678(cv_source())) == 8> t8;
return 0;
}
three sink_6_345678(volatile A&);
four sink_6_345678(const volatile A&);
five sink_6_345678( A&&);
six sink_6_345678(const A&&);
seven sink_6_345678(volatile A&&);
eight sink_6_345678(const volatile A&&);
int test6_345678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_6_345678(a)) == 3> t1;
sa<sizeof(sink_6_345678(ca)) == 4> t2;
sa<sizeof(sink_6_345678(va)) == 3> t3;
sa<sizeof(sink_6_345678(cva)) == 4> t4;
sa<sizeof(sink_6_345678(source())) == 5> t5;
sa<sizeof(sink_6_345678(c_source())) == 6> t6;
sa<sizeof(sink_6_345678(v_source())) == 7> t7;
sa<sizeof(sink_6_345678(cv_source())) == 8> t8;
return 0;
}
int main()
{
return test6_123456() + test6_123457() + test6_123458() + test6_123467() +
test6_123468() + test6_123478() + test6_123567() + test6_123568() +
test6_123578() + test6_123678() + test6_124567() + test6_124568() +
test6_124578() + test6_124678() + test6_125678() + test6_134567() +
test6_134568() + test6_134578() + test6_134678() + test6_135678() +
test6_145678() + test6_234567() + test6_234568() + test6_234578() +
test6_234678() + test6_235678() + test6_245678() + test6_345678();
}

90
gcc/testsuite/g++.dg/cpp0x/rv7n.C Normal file
View file

@ -0,0 +1,90 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 7 at a time
one sink_7_1234567( A&); // { dg-error "" }
two sink_7_1234567(const A&); // { dg-error "" }
three sink_7_1234567(volatile A&); // { dg-error "" }
four sink_7_1234567(const volatile A&); // { dg-error "" }
five sink_7_1234567( A&&); // { dg-error "" }
six sink_7_1234567(const A&&); // { dg-error "" }
seven sink_7_1234567(volatile A&&); // { dg-error "" }
int test7_1234567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_7_1234567(cv_source()); // { dg-error "no match" }
return 0;
}
two sink_7_2345678(const A&); // { dg-error "" }
three sink_7_2345678(volatile A&); // { dg-error "" }
four sink_7_2345678(const volatile A&); // { dg-error "" }
five sink_7_2345678( A&&); // { dg-error "" }
six sink_7_2345678(const A&&); // { dg-error "" }
seven sink_7_2345678(volatile A&&); // { dg-error "" }
eight sink_7_2345678(const volatile A&&); // { dg-error "" }
int test7_2345678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_7_2345678(a); // { dg-error "ambiguous" }
return 0;
}
one sink_7_1234678( A&);
two sink_7_1234678(const A&); // { dg-error "" }
three sink_7_1234678(volatile A&);
four sink_7_1234678(const volatile A&);
six sink_7_1234678(const A&&); // { dg-error "" }
seven sink_7_1234678(volatile A&&); // { dg-error "" }
eight sink_7_1234678(const volatile A&&); // { dg-error "" }
int test7_1234678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sink_7_1234678(source()); // { dg-error "ambiguous" }
return 0;
}
int main()
{
return test7_2345678() + test7_1234678();
}

234
gcc/testsuite/g++.dg/cpp0x/rv7p.C Normal file
View file

@ -0,0 +1,234 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 7 at a time
one sink_7_1234567( A&);
two sink_7_1234567(const A&);
three sink_7_1234567(volatile A&);
four sink_7_1234567(const volatile A&);
five sink_7_1234567( A&&);
six sink_7_1234567(const A&&);
seven sink_7_1234567(volatile A&&);
int test7_1234567()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1234567(a)) == 1> t1;
sa<sizeof(sink_7_1234567(ca)) == 2> t2;
sa<sizeof(sink_7_1234567(va)) == 3> t3;
sa<sizeof(sink_7_1234567(cva)) == 4> t4;
sa<sizeof(sink_7_1234567(source())) == 5> t5;
sa<sizeof(sink_7_1234567(c_source())) == 6> t6;
sa<sizeof(sink_7_1234567(v_source())) == 7> t7;
return 0;
}
one sink_7_1234568( A&);
two sink_7_1234568(const A&);
three sink_7_1234568(volatile A&);
four sink_7_1234568(const volatile A&);
five sink_7_1234568( A&&);
six sink_7_1234568(const A&&);
eight sink_7_1234568(const volatile A&&);
int test7_1234568()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1234568(a)) == 1> t1;
sa<sizeof(sink_7_1234568(ca)) == 2> t2;
sa<sizeof(sink_7_1234568(va)) == 3> t3;
sa<sizeof(sink_7_1234568(cva)) == 4> t4;
sa<sizeof(sink_7_1234568(source())) == 5> t5;
sa<sizeof(sink_7_1234568(c_source())) == 6> t6;
sa<sizeof(sink_7_1234568(v_source())) == 8> t7;
sa<sizeof(sink_7_1234568(cv_source())) == 8> t8;
return 0;
}
one sink_7_1234578( A&);
two sink_7_1234578(const A&);
three sink_7_1234578(volatile A&);
four sink_7_1234578(const volatile A&);
five sink_7_1234578( A&&);
seven sink_7_1234578(volatile A&&);
eight sink_7_1234578(const volatile A&&);
int test7_1234578()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1234578(a)) == 1> t1;
sa<sizeof(sink_7_1234578(ca)) == 2> t2;
sa<sizeof(sink_7_1234578(va)) == 3> t3;
sa<sizeof(sink_7_1234578(cva)) == 4> t4;
sa<sizeof(sink_7_1234578(source())) == 5> t5;
sa<sizeof(sink_7_1234578(c_source())) == 8> t6;
sa<sizeof(sink_7_1234578(v_source())) == 7> t7;
sa<sizeof(sink_7_1234578(cv_source())) == 8> t8;
return 0;
}
one sink_7_1234678( A&);
two sink_7_1234678(const A&);
three sink_7_1234678(volatile A&);
four sink_7_1234678(const volatile A&);
six sink_7_1234678(const A&&);
seven sink_7_1234678(volatile A&&);
eight sink_7_1234678(const volatile A&&);
int test7_1234678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1234678(a)) == 1> t1;
sa<sizeof(sink_7_1234678(ca)) == 2> t2;
sa<sizeof(sink_7_1234678(va)) == 3> t3;
sa<sizeof(sink_7_1234678(cva)) == 4> t4;
sa<sizeof(sink_7_1234678(c_source())) == 6> t6;
sa<sizeof(sink_7_1234678(v_source())) == 7> t7;
sa<sizeof(sink_7_1234678(cv_source())) == 8> t8;
return 0;
}
one sink_7_1235678( A&);
two sink_7_1235678(const A&);
three sink_7_1235678(volatile A&);
five sink_7_1235678( A&&);
six sink_7_1235678(const A&&);
seven sink_7_1235678(volatile A&&);
eight sink_7_1235678(const volatile A&&);
int test7_1235678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1235678(a)) == 1> t1;
sa<sizeof(sink_7_1235678(ca)) == 2> t2;
sa<sizeof(sink_7_1235678(va)) == 3> t3;
sa<sizeof(sink_7_1235678(cva)) == 8> t4;
sa<sizeof(sink_7_1235678(source())) == 5> t5;
sa<sizeof(sink_7_1235678(c_source())) == 6> t6;
sa<sizeof(sink_7_1235678(v_source())) == 7> t7;
sa<sizeof(sink_7_1235678(cv_source())) == 8> t8;
return 0;
}
one sink_7_1245678( A&);
two sink_7_1245678(const A&);
four sink_7_1245678(const volatile A&);
five sink_7_1245678( A&&);
six sink_7_1245678(const A&&);
seven sink_7_1245678(volatile A&&);
eight sink_7_1245678(const volatile A&&);
int test7_1245678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1245678(a)) == 1> t1;
sa<sizeof(sink_7_1245678(ca)) == 2> t2;
sa<sizeof(sink_7_1245678(va)) == 4> t3;
sa<sizeof(sink_7_1245678(cva)) == 4> t4;
sa<sizeof(sink_7_1245678(source())) == 5> t5;
sa<sizeof(sink_7_1245678(c_source())) == 6> t6;
sa<sizeof(sink_7_1245678(v_source())) == 7> t7;
sa<sizeof(sink_7_1245678(cv_source())) == 8> t8;
return 0;
}
one sink_7_1345678( A&);
three sink_7_1345678(volatile A&);
four sink_7_1345678(const volatile A&);
five sink_7_1345678( A&&);
six sink_7_1345678(const A&&);
seven sink_7_1345678(volatile A&&);
eight sink_7_1345678(const volatile A&&);
int test7_1345678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_1345678(a)) == 1> t1;
sa<sizeof(sink_7_1345678(ca)) == 4> t2;
sa<sizeof(sink_7_1345678(va)) == 3> t3;
sa<sizeof(sink_7_1345678(cva)) == 4> t4;
sa<sizeof(sink_7_1345678(source())) == 5> t5;
sa<sizeof(sink_7_1345678(c_source())) == 6> t6;
sa<sizeof(sink_7_1345678(v_source())) == 7> t7;
sa<sizeof(sink_7_1345678(cv_source())) == 8> t8;
return 0;
}
two sink_7_2345678(const A&);
three sink_7_2345678(volatile A&);
four sink_7_2345678(const volatile A&);
five sink_7_2345678( A&&);
six sink_7_2345678(const A&&);
seven sink_7_2345678(volatile A&&);
eight sink_7_2345678(const volatile A&&);
int test7_2345678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_7_2345678(ca)) == 2> t2;
sa<sizeof(sink_7_2345678(va)) == 3> t3;
sa<sizeof(sink_7_2345678(cva)) == 4> t4;
sa<sizeof(sink_7_2345678(source())) == 5> t5;
sa<sizeof(sink_7_2345678(c_source())) == 6> t6;
sa<sizeof(sink_7_2345678(v_source())) == 7> t7;
sa<sizeof(sink_7_2345678(cv_source())) == 8> t8;
return 0;
}
int main()
{
return test7_1234567() + test7_1234568() + test7_1234578() + test7_1234678() +
test7_1235678() + test7_1245678() + test7_1345678() + test7_2345678();
}

62
gcc/testsuite/g++.dg/cpp0x/rv8p.C Normal file
View file

@ -0,0 +1,62 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test overlaod resolution among referece types
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct three {char x[3];};
struct four {char x[4];};
struct five {char x[5];};
struct six {char x[6];};
struct seven {char x[7];};
struct eight {char x[8];};
struct A
{
A();
A(const volatile A&&);
};
A source();
const A c_source();
volatile A v_source();
const volatile A cv_source();
// 8 at a time
one sink_8_12345678( A&);
two sink_8_12345678(const A&);
three sink_8_12345678(volatile A&);
four sink_8_12345678(const volatile A&);
five sink_8_12345678( A&&);
six sink_8_12345678(const A&&);
seven sink_8_12345678(volatile A&&);
eight sink_8_12345678(const volatile A&&);
int test8_12345678()
{
A a;
const A ca = a;
volatile A va;
const volatile A cva = a;
sa<sizeof(sink_8_12345678(a)) == 1> t1;
sa<sizeof(sink_8_12345678(ca)) == 2> t2;
sa<sizeof(sink_8_12345678(va)) == 3> t3;
sa<sizeof(sink_8_12345678(cva)) == 4> t4;
sa<sizeof(sink_8_12345678(source())) == 5> t5;
sa<sizeof(sink_8_12345678(c_source())) == 6> t6;
sa<sizeof(sink_8_12345678(v_source())) == 7> t7;
sa<sizeof(sink_8_12345678(cv_source())) == 8> t8;
return 0;
}
int main()
{
return test8_12345678();
}

25
gcc/testsuite/g++.dg/cpp0x/rvo.C Normal file
View file

@ -0,0 +1,25 @@
// { dg-do "run" }
// { dg-options "-std=c++0x" }
// Contributed by Sylvain Pion
static int rvalue_constructions = 0;
struct A {
A () { }
A (const A&) { }
A (A&&) { ++rvalue_constructions; }
~A () { }
};
A f() { return A(); }
extern "C" {
void abort(void);
}
int main()
{
A c = f();
if (rvalue_constructions != 0)
abort();
}

15
gcc/testsuite/g++.dg/cpp0x/temp-constructor-bug.C Normal file
View file

@ -0,0 +1,15 @@
// { dg-options "--std=c++0x" }
struct S { };
struct T
{
S s;
};
void f(T const &);
void g()
{
f((T){S()});
}

10
gcc/testsuite/g++.dg/cpp0x/temp-va-arg-bug.C Normal file
View file

@ -0,0 +1,10 @@
// { dg-options "--std=c++0x" }
#include <stdarg.h>
struct S { };
void f(S const &);
void g(va_list args)
{
f(va_arg(args, S));
}

68
gcc/testsuite/g++.dg/cpp0x/template_deduction.C Normal file
View file

@ -0,0 +1,68 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test the "Augmented" template argument deduction when binding an lvalue to an rvalue reference.
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
template <class T, T v>
struct integral_constant
{
static const T value = v;
typedef T value_type;
typedef integral_constant<T, v> type;
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
template <class T> struct is_lvalue_reference : public integral_constant<bool, false> {};
template <class T> struct is_lvalue_reference<T&> : public integral_constant<bool, true> {};
template <class T> struct is_rvalue_reference : public integral_constant<bool, false> {};
template <class T> struct is_rvalue_reference<T&&> : public integral_constant<bool, true> {};
template <bool is_lvalue_ref, bool is_rvalue_ref, class T>
void
test1(T&&)
{
sa<is_lvalue_reference<T&&>::value == is_lvalue_ref> t1;
sa<is_rvalue_reference<T&&>::value == is_rvalue_ref> t2;
}
template <bool is_lvalue_ref, bool is_rvalue_ref, class T>
void
test2(const T&&)
{
sa<is_lvalue_reference<const T&&>::value == is_lvalue_ref> t1;
sa<is_rvalue_reference<const T&&>::value == is_rvalue_ref> t2;
}
template <bool is_lvalue_ref, bool is_rvalue_ref, class T>
void
test3(T*&&)
{
sa<is_lvalue_reference<T*&&>::value == is_lvalue_ref> t1;
sa<is_rvalue_reference<T*&&>::value == is_rvalue_ref> t2;
}
struct A {};
A a;
A source() {return A();}
A* sourcep() {return 0;}
int main()
{
test1<true, false>(a);
test1<false, true>(source());
test2<false, true>(a);
test2<false, true>(source());
test3<false, true>(&a);
test3<false, true>(sourcep());
return 0;
}

30
gcc/testsuite/g++.dg/cpp0x/unnamed_refs.C Normal file
View file

@ -0,0 +1,30 @@
// I, Howard Hinnant, hereby place this code in the public domain.
// Test: Unamed rvalue references are treated as lvalues.
// { dg-do compile }
// { dg-options "-std=c++0x" }
template <bool> struct sa;
template <> struct sa<true> {};
struct one {char x[1];};
struct two {char x[2];};
struct A {};
one foo(const A&) {return one();}
two foo(A&&) {return two();}
A&& source() {static A a; return a;}
int test1()
{
sa<sizeof(foo(source())) == 2> t1;
return 0;
}
int main()
{
return test1();
}

1
gcc/testsuite/g++.dg/init/copy7.C
View file

@ -1,3 +1,4 @@
// { dg-options "-std=c++98" }
// PR c++/12226
class foo {

1
gcc/testsuite/g++.dg/overload/arg1.C
View file

@ -1,3 +1,4 @@
// { dg-options "-std=c++98" }
// { dg-do compile }
// Copyright (C) 2004 Free Software Foundation, Inc.

1
gcc/testsuite/g++.dg/overload/arg4.C
View file

@ -1,3 +1,4 @@
// { dg-options "-std=c++98" }
// { dg-do compile }
// Copyright (C) 2004 Free Software Foundation, Inc.