diff options
author | Russell Yanofsky <russ@yanofsky.org> | 2007-05-31 01:18:22 +0000 |
---|---|---|
committer | Doug Gregor <dgregor@gcc.gnu.org> | 2007-05-31 01:18:22 +0000 |
commit | 8af2fec40bfd6889ab47b47d0a9cfaa5102c2507 (patch) | |
tree | 6d0815a650d1201c2dd1e4b249977bfe4379c548 /gcc/testsuite | |
parent | 0ae581acf1fbef4189f22a23a00b6d827aee4b1b (diff) | |
download | gcc-8af2fec40bfd6889ab47b47d0a9cfaa5102c2507.zip gcc-8af2fec40bfd6889ab47b47d0a9cfaa5102c2507.tar.gz gcc-8af2fec40bfd6889ab47b47d0a9cfaa5102c2507.tar.bz2 |
re PR c++/7412 ([DR 106] References to references)
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
Diffstat (limited to 'gcc/testsuite')
42 files changed, 9986 insertions, 0 deletions
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d962250..4ebf002 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -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 diff --git a/gcc/testsuite/g++.dg/cpp0x/bind.C b/gcc/testsuite/g++.dg/cpp0x/bind.C new file mode 100644 index 0000000..42a2ac2 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/bind.C @@ -0,0 +1,8 @@ +// { dg-options "--std=c++0x" } +struct S{}; +void f(S&&); + +int main() +{ + f(S()); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/cast-bug.C b/gcc/testsuite/g++.dg/cpp0x/cast-bug.C new file mode 100644 index 0000000..211f88b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/cast-bug.C @@ -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); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/cast.C b/gcc/testsuite/g++.dg/cpp0x/cast.C new file mode 100644 index 0000000..4cc7f2e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/cast.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/collapse-bug.C b/gcc/testsuite/g++.dg/cpp0x/collapse-bug.C new file mode 100644 index 0000000..02a59cd --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/collapse-bug.C @@ -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&(&)()>(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/collapse.C b/gcc/testsuite/g++.dg/cpp0x/collapse.C new file mode 100644 index 0000000..96c3273 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/collapse.C @@ -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 &>(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/deduce.C b/gcc/testsuite/g++.dg/cpp0x/deduce.C new file mode 100644 index 0000000..6bd0516 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/deduce.C @@ -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()); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/elision.C b/gcc/testsuite/g++.dg/cpp0x/elision.C new file mode 100644 index 0000000..35d5e4b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/elision.C @@ -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; diff --git a/gcc/testsuite/g++.dg/cpp0x/elision_neg.C b/gcc/testsuite/g++.dg/cpp0x/elision_neg.C new file mode 100644 index 0000000..78feac7 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/elision_neg.C @@ -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; diff --git a/gcc/testsuite/g++.dg/cpp0x/elision_weak.C b/gcc/testsuite/g++.dg/cpp0x/elision_weak.C new file mode 100644 index 0000000..e8ba755 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/elision_weak.C @@ -0,0 +1,19 @@ +// { dg-do compile } + +struct S +{ + S() {} + S(S&) {} +}; + +S f() +{ + S s; + return s; +} + +void g() +{ + S s; + throw s; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/implicit-copy.C b/gcc/testsuite/g++.dg/cpp0x/implicit-copy.C new file mode 100644 index 0000000..ea680a89 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/implicit-copy.C @@ -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; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/iop.C b/gcc/testsuite/g++.dg/cpp0x/iop.C new file mode 100644 index 0000000..5aecf9f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/iop.C @@ -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; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/named.C b/gcc/testsuite/g++.dg/cpp0x/named.C new file mode 100644 index 0000000..b91e698 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/named.C @@ -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() +{ +} diff --git a/gcc/testsuite/g++.dg/cpp0x/named_refs.C b/gcc/testsuite/g++.dg/cpp0x/named_refs.C new file mode 100644 index 0000000..96d7e78 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/named_refs.C @@ -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()); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/not_special.C b/gcc/testsuite/g++.dg/cpp0x/not_special.C new file mode 100644 index 0000000..f94b82a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/not_special.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/overload-conv-1.C b/gcc/testsuite/g++.dg/cpp0x/overload-conv-1.C new file mode 100644 index 0000000..7781112 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/overload-conv-1.C @@ -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); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/overload-conv-2.C b/gcc/testsuite/g++.dg/cpp0x/overload-conv-2.C new file mode 100644 index 0000000..0e622bc --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/overload-conv-2.C @@ -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); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/overload.C b/gcc/testsuite/g++.dg/cpp0x/overload.C new file mode 100644 index 0000000..945860c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/overload.C @@ -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; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/reference_collapsing.C b/gcc/testsuite/g++.dg/cpp0x/reference_collapsing.C new file mode 100644 index 0000000..5b682e3 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/reference_collapsing.C @@ -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; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv1n.C b/gcc/testsuite/g++.dg/cpp0x/rv1n.C new file mode 100644 index 0000000..10b5dc2 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv1n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv1p.C b/gcc/testsuite/g++.dg/cpp0x/rv1p.C new file mode 100644 index 0000000..6241885 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv1p.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv2n.C b/gcc/testsuite/g++.dg/cpp0x/rv2n.C new file mode 100644 index 0000000..df35358 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv2n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv2p.C b/gcc/testsuite/g++.dg/cpp0x/rv2p.C new file mode 100644 index 0000000..0d12aac --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv2p.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv3n.C b/gcc/testsuite/g++.dg/cpp0x/rv3n.C new file mode 100644 index 0000000..e04ef4f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv3n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv3p.C b/gcc/testsuite/g++.dg/cpp0x/rv3p.C new file mode 100644 index 0000000..c688b11 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv3p.C @@ -0,0 +1,1120 @@ +// 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&); +two sink_3_123(const A&); +three sink_3_123(volatile A&); + +int test3_123() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_123(a)) == 1> t1; + sa<sizeof(sink_3_123(ca)) == 2> t2; + sa<sizeof(sink_3_123(va)) == 3> t3; + sa<sizeof(sink_3_123(source())) == 2> t5; + sa<sizeof(sink_3_123(c_source())) == 2> t6; + return 0; +} + +one sink_3_124( A&); +two sink_3_124(const A&); +four sink_3_124(const volatile A&); + +int test3_124() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_124(a)) == 1> t1; + sa<sizeof(sink_3_124(ca)) == 2> t2; + sa<sizeof(sink_3_124(va)) == 4> t3; + sa<sizeof(sink_3_124(cva)) == 4> t4; + sa<sizeof(sink_3_124(source())) == 2> t5; + sa<sizeof(sink_3_124(c_source())) == 2> t6; + return 0; +} + +one sink_3_125( A&); +two sink_3_125(const A&); +five sink_3_125( A&&); + +int test3_125() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_125(a)) == 1> t1; + sa<sizeof(sink_3_125(ca)) == 2> t2; + sa<sizeof(sink_3_125(source())) == 5> t5; + sa<sizeof(sink_3_125(c_source())) == 2> t6; + return 0; +} + +one sink_3_126( A&); +two sink_3_126(const A&); +six sink_3_126(const A&&); + +int test3_126() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_126(a)) == 1> t1; + sa<sizeof(sink_3_126(ca)) == 2> t2; + sa<sizeof(sink_3_126(source())) == 6> t5; + sa<sizeof(sink_3_126(c_source())) == 6> t6; + return 0; +} + +one sink_3_127( A&); +two sink_3_127(const A&); +seven sink_3_127(volatile A&&); + +int test3_127() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_127(a)) == 1> t1; + sa<sizeof(sink_3_127(ca)) == 2> t2; + sa<sizeof(sink_3_127(va)) == 7> t3; + sa<sizeof(sink_3_127(source())) == 7> t5; + sa<sizeof(sink_3_127(c_source())) == 2> t6; + sa<sizeof(sink_3_127(v_source())) == 7> t7; + return 0; +} + +one sink_3_128( A&); +two sink_3_128(const A&); +eight sink_3_128(const volatile A&&); + +int test3_128() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_128(a)) == 1> t1; + sa<sizeof(sink_3_128(ca)) == 2> t2; + sa<sizeof(sink_3_128(va)) == 8> t3; + sa<sizeof(sink_3_128(cva)) == 8> t4; + sa<sizeof(sink_3_128(source())) == 8> t5; + sa<sizeof(sink_3_128(c_source())) == 8> t6; + sa<sizeof(sink_3_128(v_source())) == 8> t7; + sa<sizeof(sink_3_128(cv_source())) == 8> t8; + return 0; +} + +one sink_3_134( A&); +three sink_3_134(volatile A&); +four sink_3_134(const volatile A&); + +int test3_134() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_134(a)) == 1> t1; + sa<sizeof(sink_3_134(ca)) == 4> t2; + sa<sizeof(sink_3_134(va)) == 3> t3; + sa<sizeof(sink_3_134(cva)) == 4> t4; + return 0; +} + +one sink_3_135( A&); +three sink_3_135(volatile A&); +five sink_3_135( A&&); + +int test3_135() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_135(a)) == 1> t1; + sa<sizeof(sink_3_135(va)) == 3> t3; + sa<sizeof(sink_3_135(source())) == 5> t5; + return 0; +} + +one sink_3_136( A&); +three sink_3_136(volatile A&); +six sink_3_136(const A&&); + +int test3_136() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_136(a)) == 1> t1; + sa<sizeof(sink_3_136(ca)) == 6> t2; + sa<sizeof(sink_3_136(va)) == 3> t3; + sa<sizeof(sink_3_136(source())) == 6> t5; + sa<sizeof(sink_3_136(c_source())) == 6> t6; + return 0; +} + +one sink_3_137( A&); +three sink_3_137(volatile A&); +seven sink_3_137(volatile A&&); + +int test3_137() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_137(a)) == 1> t1; + sa<sizeof(sink_3_137(va)) == 3> t3; + sa<sizeof(sink_3_137(source())) == 7> t5; + sa<sizeof(sink_3_137(v_source())) == 7> t7; + return 0; +} + +one sink_3_138( A&); +three sink_3_138(volatile A&); +eight sink_3_138(const volatile A&&); + +int test3_138() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_138(a)) == 1> t1; + sa<sizeof(sink_3_138(ca)) == 8> t2; + sa<sizeof(sink_3_138(va)) == 3> t3; + sa<sizeof(sink_3_138(cva)) == 8> t4; + sa<sizeof(sink_3_138(source())) == 8> t5; + sa<sizeof(sink_3_138(c_source())) == 8> t6; + sa<sizeof(sink_3_138(v_source())) == 8> t7; + sa<sizeof(sink_3_138(cv_source())) == 8> t8; + return 0; +} + +one sink_3_145( A&); +four sink_3_145(const volatile A&); +five sink_3_145( A&&); + +int test3_145() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_145(a)) == 1> t1; + sa<sizeof(sink_3_145(ca)) == 4> t2; + sa<sizeof(sink_3_145(va)) == 4> t3; + sa<sizeof(sink_3_145(cva)) == 4> t4; + sa<sizeof(sink_3_145(source())) == 5> t5; + return 0; +} + +one sink_3_146( A&); +four sink_3_146(const volatile A&); +six sink_3_146(const A&&); + +int test3_146() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_146(a)) == 1> t1; + sa<sizeof(sink_3_146(ca)) == 4> t2; + sa<sizeof(sink_3_146(va)) == 4> t3; + sa<sizeof(sink_3_146(cva)) == 4> t4; + sa<sizeof(sink_3_146(source())) == 6> t5; + sa<sizeof(sink_3_146(c_source())) == 6> t6; + return 0; +} + +one sink_3_147( A&); +four sink_3_147(const volatile A&); +seven sink_3_147(volatile A&&); + +int test3_147() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_147(a)) == 1> t1; + sa<sizeof(sink_3_147(ca)) == 4> t2; + sa<sizeof(sink_3_147(va)) == 4> t3; + sa<sizeof(sink_3_147(cva)) == 4> t4; + sa<sizeof(sink_3_147(source())) == 7> t5; + sa<sizeof(sink_3_147(v_source())) == 7> t7; + return 0; +} + +one sink_3_148( A&); +four sink_3_148(const volatile A&); +eight sink_3_148(const volatile A&&); + +int test3_148() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_148(a)) == 1> t1; + sa<sizeof(sink_3_148(ca)) == 4> t2; + sa<sizeof(sink_3_148(va)) == 4> t3; + sa<sizeof(sink_3_148(cva)) == 4> t4; + sa<sizeof(sink_3_148(source())) == 8> t5; + sa<sizeof(sink_3_148(c_source())) == 8> t6; + sa<sizeof(sink_3_148(v_source())) == 8> t7; + sa<sizeof(sink_3_148(cv_source())) == 8> t8; + return 0; +} + +one sink_3_156( A&); +five sink_3_156( A&&); +six sink_3_156(const A&&); + +int test3_156() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_156(a)) == 1> t1; + sa<sizeof(sink_3_156(ca)) == 6> t2; + sa<sizeof(sink_3_156(source())) == 5> t5; + sa<sizeof(sink_3_156(c_source())) == 6> t6; + return 0; +} + +one sink_3_157( A&); +five sink_3_157( A&&); +seven sink_3_157(volatile A&&); + +int test3_157() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_157(a)) == 1> t1; + sa<sizeof(sink_3_157(va)) == 7> t3; + sa<sizeof(sink_3_157(source())) == 5> t5; + sa<sizeof(sink_3_157(v_source())) == 7> t7; + return 0; +} + +one sink_3_158( A&); +five sink_3_158( A&&); +eight sink_3_158(const volatile A&&); + +int test3_158() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_158(a)) == 1> t1; + sa<sizeof(sink_3_158(ca)) == 8> t2; + sa<sizeof(sink_3_158(va)) == 8> t3; + sa<sizeof(sink_3_158(cva)) == 8> t4; + sa<sizeof(sink_3_158(source())) == 5> t5; + sa<sizeof(sink_3_158(c_source())) == 8> t6; + sa<sizeof(sink_3_158(v_source())) == 8> t7; + sa<sizeof(sink_3_158(cv_source())) == 8> t8; + return 0; +} + +one sink_3_167( A&); +six sink_3_167(const A&&); +seven sink_3_167(volatile A&&); + +int test3_167() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_167(a)) == 1> t1; + sa<sizeof(sink_3_167(ca)) == 6> t2; + sa<sizeof(sink_3_167(va)) == 7> t3; + sa<sizeof(sink_3_167(c_source())) == 6> t6; + sa<sizeof(sink_3_167(v_source())) == 7> t7; + return 0; +} + +one sink_3_168( A&); +six sink_3_168(const A&&); +eight sink_3_168(const volatile A&&); + +int test3_168() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_168(a)) == 1> t1; + sa<sizeof(sink_3_168(ca)) == 6> t2; + sa<sizeof(sink_3_168(va)) == 8> t3; + sa<sizeof(sink_3_168(cva)) == 8> t4; + sa<sizeof(sink_3_168(source())) == 6> t5; + sa<sizeof(sink_3_168(c_source())) == 6> t6; + sa<sizeof(sink_3_168(v_source())) == 8> t7; + sa<sizeof(sink_3_168(cv_source())) == 8> t8; + return 0; +} + +one sink_3_178( A&); +seven sink_3_178(volatile A&&); +eight sink_3_178(const volatile A&&); + +int test3_178() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_178(a)) == 1> t1; + sa<sizeof(sink_3_178(ca)) == 8> t2; + sa<sizeof(sink_3_178(va)) == 7> t3; + sa<sizeof(sink_3_178(cva)) == 8> t4; + sa<sizeof(sink_3_178(source())) == 7> t5; + sa<sizeof(sink_3_178(c_source())) == 8> t6; + sa<sizeof(sink_3_178(v_source())) == 7> t7; + sa<sizeof(sink_3_178(cv_source())) == 8> t8; + return 0; +} + +two sink_3_234(const A&); +three sink_3_234(volatile A&); +four sink_3_234(const volatile A&); + +int test3_234() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_234(ca)) == 2> t2; + sa<sizeof(sink_3_234(va)) == 3> t3; + sa<sizeof(sink_3_234(cva)) == 4> t4; + sa<sizeof(sink_3_234(source())) == 2> t5; + sa<sizeof(sink_3_234(c_source())) == 2> t6; + return 0; +} + +two sink_3_235(const A&); +three sink_3_235(volatile A&); +five sink_3_235( A&&); + +int test3_235() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_235(ca)) == 2> t2; + sa<sizeof(sink_3_235(va)) == 3> t3; + sa<sizeof(sink_3_235(source())) == 5> t5; + sa<sizeof(sink_3_235(c_source())) == 2> t6; + return 0; +} + +two sink_3_236(const A&); +three sink_3_236(volatile A&); +six sink_3_236(const A&&); + +int test3_236() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_236(ca)) == 2> t2; + sa<sizeof(sink_3_236(va)) == 3> t3; + sa<sizeof(sink_3_236(source())) == 6> t5; + sa<sizeof(sink_3_236(c_source())) == 6> t6; + return 0; +} + +two sink_3_237(const A&); +three sink_3_237(volatile A&); +seven sink_3_237(volatile A&&); + +int test3_237() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_237(ca)) == 2> t2; + sa<sizeof(sink_3_237(va)) == 3> t3; + sa<sizeof(sink_3_237(source())) == 7> t5; + sa<sizeof(sink_3_237(c_source())) == 2> t6; + sa<sizeof(sink_3_237(v_source())) == 7> t7; + return 0; +} + +two sink_3_238(const A&); +three sink_3_238(volatile A&); +eight sink_3_238(const volatile A&&); + +int test3_238() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_238(ca)) == 2> t2; + sa<sizeof(sink_3_238(va)) == 3> t3; + sa<sizeof(sink_3_238(cva)) == 8> t4; + sa<sizeof(sink_3_238(source())) == 8> t5; + sa<sizeof(sink_3_238(c_source())) == 8> t6; + sa<sizeof(sink_3_238(v_source())) == 8> t7; + sa<sizeof(sink_3_238(cv_source())) == 8> t8; + return 0; +} + +two sink_3_245(const A&); +four sink_3_245(const volatile A&); +five sink_3_245( A&&); + +int test3_245() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_245(a)) == 2> t1; + sa<sizeof(sink_3_245(ca)) == 2> t2; + sa<sizeof(sink_3_245(va)) == 4> t3; + sa<sizeof(sink_3_245(cva)) == 4> t4; + sa<sizeof(sink_3_245(source())) == 5> t5; + sa<sizeof(sink_3_245(c_source())) == 2> t6; + return 0; +} + +two sink_3_246(const A&); +four sink_3_246(const volatile A&); +six sink_3_246(const A&&); + +int test3_246() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_246(a)) == 2> t1; + sa<sizeof(sink_3_246(ca)) == 2> t2; + sa<sizeof(sink_3_246(va)) == 4> t3; + sa<sizeof(sink_3_246(cva)) == 4> t4; + sa<sizeof(sink_3_246(source())) == 6> t5; + sa<sizeof(sink_3_246(c_source())) == 6> t6; + return 0; +} + +two sink_3_247(const A&); +four sink_3_247(const volatile A&); +seven sink_3_247(volatile A&&); + +int test3_247() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_247(a)) == 2> t1; + sa<sizeof(sink_3_247(ca)) == 2> t2; + sa<sizeof(sink_3_247(va)) == 4> t3; + sa<sizeof(sink_3_247(cva)) == 4> t4; + sa<sizeof(sink_3_247(source())) == 7> t5; + sa<sizeof(sink_3_247(c_source())) == 2> t6; + sa<sizeof(sink_3_247(v_source())) == 7> t7; + return 0; +} + +two sink_3_248(const A&); +four sink_3_248(const volatile A&); +eight sink_3_248(const volatile A&&); + +int test3_248() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_248(a)) == 2> t1; + sa<sizeof(sink_3_248(ca)) == 2> t2; + sa<sizeof(sink_3_248(va)) == 4> t3; + sa<sizeof(sink_3_248(cva)) == 4> t4; + sa<sizeof(sink_3_248(source())) == 8> t5; + sa<sizeof(sink_3_248(c_source())) == 8> t6; + sa<sizeof(sink_3_248(v_source())) == 8> t7; + sa<sizeof(sink_3_248(cv_source())) == 8> t8; + return 0; +} + +two sink_3_256(const A&); +five sink_3_256( A&&); +six sink_3_256(const A&&); + +int test3_256() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_256(a)) == 2> t1; + sa<sizeof(sink_3_256(ca)) == 2> t2; + sa<sizeof(sink_3_256(source())) == 5> t5; + sa<sizeof(sink_3_256(c_source())) == 6> t6; + return 0; +} + +two sink_3_257(const A&); +five sink_3_257( A&&); +seven sink_3_257(volatile A&&); + +int test3_257() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_257(a)) == 2> t1; + sa<sizeof(sink_3_257(ca)) == 2> t2; + sa<sizeof(sink_3_257(va)) == 7> t3; + sa<sizeof(sink_3_257(source())) == 5> t5; + sa<sizeof(sink_3_257(c_source())) == 2> t6; + sa<sizeof(sink_3_257(v_source())) == 7> t7; + return 0; +} + +two sink_3_258(const A&); +five sink_3_258( A&&); +eight sink_3_258(const volatile A&&); + +int test3_258() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_258(a)) == 2> t1; + sa<sizeof(sink_3_258(ca)) == 2> t2; + sa<sizeof(sink_3_258(va)) == 8> t3; + sa<sizeof(sink_3_258(cva)) == 8> t4; + sa<sizeof(sink_3_258(source())) == 5> t5; + sa<sizeof(sink_3_258(c_source())) == 8> t6; + sa<sizeof(sink_3_258(v_source())) == 8> t7; + sa<sizeof(sink_3_258(cv_source())) == 8> t8; + return 0; +} + +two sink_3_267(const A&); +six sink_3_267(const A&&); +seven sink_3_267(volatile A&&); + +int test3_267() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_267(a)) == 2> t1; + sa<sizeof(sink_3_267(ca)) == 2> t2; + sa<sizeof(sink_3_267(va)) == 7> t3; + sa<sizeof(sink_3_267(c_source())) == 6> t6; + sa<sizeof(sink_3_267(v_source())) == 7> t7; + return 0; +} + +two sink_3_268(const A&); +six sink_3_268(const A&&); +eight sink_3_268(const volatile A&&); + +int test3_268() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_268(a)) == 2> t1; + sa<sizeof(sink_3_268(ca)) == 2> t2; + sa<sizeof(sink_3_268(va)) == 8> t3; + sa<sizeof(sink_3_268(cva)) == 8> t4; + sa<sizeof(sink_3_268(source())) == 6> t5; + sa<sizeof(sink_3_268(c_source())) == 6> t6; + sa<sizeof(sink_3_268(v_source())) == 8> t7; + sa<sizeof(sink_3_268(cv_source())) == 8> t8; + return 0; +} + +two sink_3_278(const A&); +seven sink_3_278(volatile A&&); +eight sink_3_278(const volatile A&&); + +int test3_278() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_278(a)) == 2> t1; + sa<sizeof(sink_3_278(ca)) == 2> t2; + sa<sizeof(sink_3_278(va)) == 7> t3; + sa<sizeof(sink_3_278(cva)) == 8> t4; + sa<sizeof(sink_3_278(source())) == 7> t5; + sa<sizeof(sink_3_278(c_source())) == 8> t6; + sa<sizeof(sink_3_278(v_source())) == 7> t7; + sa<sizeof(sink_3_278(cv_source())) == 8> t8; + return 0; +} + +three sink_3_345(volatile A&); +four sink_3_345(const volatile A&); +five sink_3_345( A&&); + +int test3_345() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_345(a)) == 3> t1; + sa<sizeof(sink_3_345(ca)) == 4> t2; + sa<sizeof(sink_3_345(va)) == 3> t3; + sa<sizeof(sink_3_345(cva)) == 4> t4; + sa<sizeof(sink_3_345(source())) == 5> t5; + return 0; +} + +three sink_3_346(volatile A&); +four sink_3_346(const volatile A&); +six sink_3_346(const A&&); + +int test3_346() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_346(a)) == 3> t1; + sa<sizeof(sink_3_346(ca)) == 4> t2; + sa<sizeof(sink_3_346(va)) == 3> t3; + sa<sizeof(sink_3_346(cva)) == 4> t4; + sa<sizeof(sink_3_346(source())) == 6> t5; + sa<sizeof(sink_3_346(c_source())) == 6> t6; + return 0; +} + +three sink_3_347(volatile A&); +four sink_3_347(const volatile A&); +seven sink_3_347(volatile A&&); + +int test3_347() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_347(a)) == 3> t1; + sa<sizeof(sink_3_347(ca)) == 4> t2; + sa<sizeof(sink_3_347(va)) == 3> t3; + sa<sizeof(sink_3_347(cva)) == 4> t4; + sa<sizeof(sink_3_347(source())) == 7> t5; + sa<sizeof(sink_3_347(v_source())) == 7> t7; + return 0; +} + +three sink_3_348(volatile A&); +four sink_3_348(const volatile A&); +eight sink_3_348(const volatile A&&); + +int test3_348() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_348(a)) == 3> t1; + sa<sizeof(sink_3_348(ca)) == 4> t2; + sa<sizeof(sink_3_348(va)) == 3> t3; + sa<sizeof(sink_3_348(cva)) == 4> t4; + sa<sizeof(sink_3_348(source())) == 8> t5; + sa<sizeof(sink_3_348(c_source())) == 8> t6; + sa<sizeof(sink_3_348(v_source())) == 8> t7; + sa<sizeof(sink_3_348(cv_source())) == 8> t8; + return 0; +} + +three sink_3_356(volatile A&); +five sink_3_356( A&&); +six sink_3_356(const A&&); + +int test3_356() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_356(a)) == 3> t1; + sa<sizeof(sink_3_356(ca)) == 6> t2; + sa<sizeof(sink_3_356(va)) == 3> t3; + sa<sizeof(sink_3_356(source())) == 5> t5; + sa<sizeof(sink_3_356(c_source())) == 6> t6; + return 0; +} + +three sink_3_357(volatile A&); +five sink_3_357( A&&); +seven sink_3_357(volatile A&&); + +int test3_357() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_357(a)) == 3> t1; + sa<sizeof(sink_3_357(va)) == 3> t3; + sa<sizeof(sink_3_357(source())) == 5> t5; + sa<sizeof(sink_3_357(v_source())) == 7> t7; + return 0; +} + +three sink_3_358(volatile A&); +five sink_3_358( A&&); +eight sink_3_358(const volatile A&&); + +int test3_358() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_358(a)) == 3> t1; + sa<sizeof(sink_3_358(ca)) == 8> t2; + sa<sizeof(sink_3_358(va)) == 3> t3; + sa<sizeof(sink_3_358(cva)) == 8> t4; + sa<sizeof(sink_3_358(source())) == 5> t5; + sa<sizeof(sink_3_358(c_source())) == 8> t6; + sa<sizeof(sink_3_358(v_source())) == 8> t7; + sa<sizeof(sink_3_358(cv_source())) == 8> t8; + return 0; +} + +three sink_3_367(volatile A&); +six sink_3_367(const A&&); +seven sink_3_367(volatile A&&); + +int test3_367() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_367(a)) == 3> t1; + sa<sizeof(sink_3_367(ca)) == 6> t2; + sa<sizeof(sink_3_367(va)) == 3> t3; + sa<sizeof(sink_3_367(c_source())) == 6> t6; + sa<sizeof(sink_3_367(v_source())) == 7> t7; + return 0; +} + +three sink_3_368(volatile A&); +six sink_3_368(const A&&); +eight sink_3_368(const volatile A&&); + +int test3_368() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_368(a)) == 3> t1; + sa<sizeof(sink_3_368(ca)) == 6> t2; + sa<sizeof(sink_3_368(va)) == 3> t3; + sa<sizeof(sink_3_368(cva)) == 8> t4; + sa<sizeof(sink_3_368(source())) == 6> t5; + sa<sizeof(sink_3_368(c_source())) == 6> t6; + sa<sizeof(sink_3_368(v_source())) == 8> t7; + sa<sizeof(sink_3_368(cv_source())) == 8> t8; + return 0; +} + +three sink_3_378(volatile A&); +seven sink_3_378(volatile A&&); +eight sink_3_378(const volatile A&&); + +int test3_378() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_378(a)) == 3> t1; + sa<sizeof(sink_3_378(ca)) == 8> t2; + sa<sizeof(sink_3_378(va)) == 3> t3; + sa<sizeof(sink_3_378(cva)) == 8> t4; + sa<sizeof(sink_3_378(source())) == 7> t5; + sa<sizeof(sink_3_378(c_source())) == 8> t6; + sa<sizeof(sink_3_378(v_source())) == 7> t7; + sa<sizeof(sink_3_378(cv_source())) == 8> t8; + return 0; +} + +four sink_3_456(const volatile A&); +five sink_3_456( A&&); +six sink_3_456(const A&&); + +int test3_456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_456(a)) == 4> t1; + sa<sizeof(sink_3_456(ca)) == 4> t2; + sa<sizeof(sink_3_456(va)) == 4> t3; + sa<sizeof(sink_3_456(cva)) == 4> t4; + sa<sizeof(sink_3_456(source())) == 5> t5; + sa<sizeof(sink_3_456(c_source())) == 6> t6; + return 0; +} + +four sink_3_457(const volatile A&); +five sink_3_457( A&&); +seven sink_3_457(volatile A&&); + +int test3_457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_457(a)) == 4> t1; + sa<sizeof(sink_3_457(ca)) == 4> t2; + sa<sizeof(sink_3_457(va)) == 4> t3; + sa<sizeof(sink_3_457(cva)) == 4> t4; + sa<sizeof(sink_3_457(source())) == 5> t5; + sa<sizeof(sink_3_457(v_source())) == 7> t7; + return 0; +} + +four sink_3_458(const volatile A&); +five sink_3_458( A&&); +eight sink_3_458(const volatile A&&); + +int test3_458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_458(a)) == 4> t1; + sa<sizeof(sink_3_458(ca)) == 4> t2; + sa<sizeof(sink_3_458(va)) == 4> t3; + sa<sizeof(sink_3_458(cva)) == 4> t4; + sa<sizeof(sink_3_458(source())) == 5> t5; + sa<sizeof(sink_3_458(c_source())) == 8> t6; + sa<sizeof(sink_3_458(v_source())) == 8> t7; + sa<sizeof(sink_3_458(cv_source())) == 8> t8; + return 0; +} + +four sink_3_467(const volatile A&); +six sink_3_467(const A&&); +seven sink_3_467(volatile A&&); + +int test3_467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_467(a)) == 4> t1; + sa<sizeof(sink_3_467(ca)) == 4> t2; + sa<sizeof(sink_3_467(va)) == 4> t3; + sa<sizeof(sink_3_467(cva)) == 4> t4; + sa<sizeof(sink_3_467(c_source())) == 6> t6; + sa<sizeof(sink_3_467(v_source())) == 7> t7; + return 0; +} + +four sink_3_468(const volatile A&); +six sink_3_468(const A&&); +eight sink_3_468(const volatile A&&); + +int test3_468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_468(a)) == 4> t1; + sa<sizeof(sink_3_468(ca)) == 4> t2; + sa<sizeof(sink_3_468(va)) == 4> t3; + sa<sizeof(sink_3_468(cva)) == 4> t4; + sa<sizeof(sink_3_468(source())) == 6> t5; + sa<sizeof(sink_3_468(c_source())) == 6> t6; + sa<sizeof(sink_3_468(v_source())) == 8> t7; + sa<sizeof(sink_3_468(cv_source())) == 8> t8; + return 0; +} + +four sink_3_478(const volatile A&); +seven sink_3_478(volatile A&&); +eight sink_3_478(const volatile A&&); + +int test3_478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_478(a)) == 4> t1; + sa<sizeof(sink_3_478(ca)) == 4> t2; + sa<sizeof(sink_3_478(va)) == 4> t3; + sa<sizeof(sink_3_478(cva)) == 4> t4; + sa<sizeof(sink_3_478(source())) == 7> t5; + sa<sizeof(sink_3_478(c_source())) == 8> t6; + sa<sizeof(sink_3_478(v_source())) == 7> t7; + sa<sizeof(sink_3_478(cv_source())) == 8> t8; + return 0; +} + +five sink_3_567( A&&); +six sink_3_567(const A&&); +seven sink_3_567(volatile A&&); + +int test3_567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_567(a)) == 5> t1; + sa<sizeof(sink_3_567(ca)) == 6> t2; + sa<sizeof(sink_3_567(va)) == 7> t3; + sa<sizeof(sink_3_567(source())) == 5> t5; + sa<sizeof(sink_3_567(c_source())) == 6> t6; + sa<sizeof(sink_3_567(v_source())) == 7> t7; + return 0; +} + +five sink_3_568( A&&); +six sink_3_568(const A&&); +eight sink_3_568(const volatile A&&); + +int test3_568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_568(a)) == 5> t1; + sa<sizeof(sink_3_568(ca)) == 6> t2; + sa<sizeof(sink_3_568(va)) == 8> t3; + sa<sizeof(sink_3_568(cva)) == 8> t4; + sa<sizeof(sink_3_568(source())) == 5> t5; + sa<sizeof(sink_3_568(c_source())) == 6> t6; + sa<sizeof(sink_3_568(v_source())) == 8> t7; + sa<sizeof(sink_3_568(cv_source())) == 8> t8; + return 0; +} + +five sink_3_578( A&&); +seven sink_3_578(volatile A&&); +eight sink_3_578(const volatile A&&); + +int test3_578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_578(a)) == 5> t1; + sa<sizeof(sink_3_578(ca)) == 8> t2; + sa<sizeof(sink_3_578(va)) == 7> t3; + sa<sizeof(sink_3_578(cva)) == 8> t4; + sa<sizeof(sink_3_578(source())) == 5> t5; + sa<sizeof(sink_3_578(c_source())) == 8> t6; + sa<sizeof(sink_3_578(v_source())) == 7> t7; + sa<sizeof(sink_3_578(cv_source())) == 8> t8; + return 0; +} + +six sink_3_678(const A&&); +seven sink_3_678(volatile A&&); +eight sink_3_678(const volatile A&&); + +int test3_678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_3_678(ca)) == 6> t2; + sa<sizeof(sink_3_678(va)) == 7> t3; + sa<sizeof(sink_3_678(cva)) == 8> t4; + sa<sizeof(sink_3_678(c_source())) == 6> t6; + sa<sizeof(sink_3_678(v_source())) == 7> t7; + sa<sizeof(sink_3_678(cv_source())) == 8> t8; + return 0; +} + +int main() +{ + return test3_123() + test3_124() + test3_125() + test3_126() + + test3_127() + test3_128() + test3_134() + test3_135() + + test3_136() + test3_137() + test3_138() + test3_145() + + test3_146() + test3_147() + test3_148() + test3_156() + + test3_157() + test3_158() + test3_167() + test3_168() + + test3_178() + test3_234() + test3_235() + test3_236() + + test3_237() + test3_238() + test3_245() + test3_246() + + test3_247() + test3_248() + test3_256() + test3_257() + + test3_258() + test3_267() + test3_268() + test3_278() + + test3_345() + test3_346() + test3_347() + test3_348() + + test3_356() + test3_357() + test3_358() + test3_367() + + test3_368() + test3_378() + test3_456() + test3_457() + + test3_458() + test3_467() + test3_468() + test3_478() + + test3_567() + test3_568() + test3_578() + test3_678(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv4n.C b/gcc/testsuite/g++.dg/cpp0x/rv4n.C new file mode 100644 index 0000000..302ab8e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv4n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv4p.C b/gcc/testsuite/g++.dg/cpp0x/rv4p.C new file mode 100644 index 0000000..a486e75 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv4p.C @@ -0,0 +1,1497 @@ +// 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&); +two sink_4_1234(const A&); +three sink_4_1234(volatile A&); +four sink_4_1234(const volatile A&); + +int test4_1234() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1234(a)) == 1> t1; + sa<sizeof(sink_4_1234(ca)) == 2> t2; + sa<sizeof(sink_4_1234(va)) == 3> t3; + sa<sizeof(sink_4_1234(cva)) == 4> t4; + sa<sizeof(sink_4_1234(source())) == 2> t5; + sa<sizeof(sink_4_1234(c_source())) == 2> t6; + return 0; +} + +one sink_4_1235( A&); +two sink_4_1235(const A&); +three sink_4_1235(volatile A&); +five sink_4_1235( A&&); + +int test4_1235() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1235(a)) == 1> t1; + sa<sizeof(sink_4_1235(ca)) == 2> t2; + sa<sizeof(sink_4_1235(va)) == 3> t3; + sa<sizeof(sink_4_1235(source())) == 5> t5; + sa<sizeof(sink_4_1235(c_source())) == 2> t6; + return 0; +} + +one sink_4_1236( A&); +two sink_4_1236(const A&); +three sink_4_1236(volatile A&); +six sink_4_1236(const A&&); + +int test4_1236() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1236(a)) == 1> t1; + sa<sizeof(sink_4_1236(ca)) == 2> t2; + sa<sizeof(sink_4_1236(va)) == 3> t3; + sa<sizeof(sink_4_1236(source())) == 6> t5; + sa<sizeof(sink_4_1236(c_source())) == 6> t6; + return 0; +} + +one sink_4_1237( A&); +two sink_4_1237(const A&); +three sink_4_1237(volatile A&); +seven sink_4_1237(volatile A&&); + +int test4_1237() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1237(a)) == 1> t1; + sa<sizeof(sink_4_1237(ca)) == 2> t2; + sa<sizeof(sink_4_1237(va)) == 3> t3; + sa<sizeof(sink_4_1237(source())) == 7> t5; + sa<sizeof(sink_4_1237(c_source())) == 2> t6; + sa<sizeof(sink_4_1237(v_source())) == 7> t7; + return 0; +} + +one sink_4_1238( A&); +two sink_4_1238(const A&); +three sink_4_1238(volatile A&); +eight sink_4_1238(const volatile A&&); + +int test4_1238() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1238(a)) == 1> t1; + sa<sizeof(sink_4_1238(ca)) == 2> t2; + sa<sizeof(sink_4_1238(va)) == 3> t3; + sa<sizeof(sink_4_1238(cva)) == 8> t4; + sa<sizeof(sink_4_1238(source())) == 8> t5; + sa<sizeof(sink_4_1238(c_source())) == 8> t6; + sa<sizeof(sink_4_1238(v_source())) == 8> t7; + sa<sizeof(sink_4_1238(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1245( A&); +two sink_4_1245(const A&); +four sink_4_1245(const volatile A&); +five sink_4_1245( A&&); + +int test4_1245() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1245(a)) == 1> t1; + sa<sizeof(sink_4_1245(ca)) == 2> t2; + sa<sizeof(sink_4_1245(va)) == 4> t3; + sa<sizeof(sink_4_1245(cva)) == 4> t4; + sa<sizeof(sink_4_1245(source())) == 5> t5; + sa<sizeof(sink_4_1245(c_source())) == 2> t6; + return 0; +} + +one sink_4_1246( A&); +two sink_4_1246(const A&); +four sink_4_1246(const volatile A&); +six sink_4_1246(const A&&); + +int test4_1246() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1246(a)) == 1> t1; + sa<sizeof(sink_4_1246(ca)) == 2> t2; + sa<sizeof(sink_4_1246(va)) == 4> t3; + sa<sizeof(sink_4_1246(cva)) == 4> t4; + sa<sizeof(sink_4_1246(source())) == 6> t5; + sa<sizeof(sink_4_1246(c_source())) == 6> t6; + return 0; +} + +one sink_4_1247( A&); +two sink_4_1247(const A&); +four sink_4_1247(const volatile A&); +seven sink_4_1247(volatile A&&); + +int test4_1247() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1247(a)) == 1> t1; + sa<sizeof(sink_4_1247(ca)) == 2> t2; + sa<sizeof(sink_4_1247(va)) == 4> t3; + sa<sizeof(sink_4_1247(cva)) == 4> t4; + sa<sizeof(sink_4_1247(source())) == 7> t5; + sa<sizeof(sink_4_1247(c_source())) == 2> t6; + sa<sizeof(sink_4_1247(v_source())) == 7> t7; + return 0; +} + +one sink_4_1248( A&); +two sink_4_1248(const A&); +four sink_4_1248(const volatile A&); +eight sink_4_1248(const volatile A&&); + +int test4_1248() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1248(a)) == 1> t1; + sa<sizeof(sink_4_1248(ca)) == 2> t2; + sa<sizeof(sink_4_1248(va)) == 4> t3; + sa<sizeof(sink_4_1248(cva)) == 4> t4; + sa<sizeof(sink_4_1248(source())) == 8> t5; + sa<sizeof(sink_4_1248(c_source())) == 8> t6; + sa<sizeof(sink_4_1248(v_source())) == 8> t7; + sa<sizeof(sink_4_1248(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1256( A&); +two sink_4_1256(const A&); +five sink_4_1256( A&&); +six sink_4_1256(const A&&); + +int test4_1256() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1256(a)) == 1> t1; + sa<sizeof(sink_4_1256(ca)) == 2> t2; + sa<sizeof(sink_4_1256(source())) == 5> t5; + sa<sizeof(sink_4_1256(c_source())) == 6> t6; + return 0; +} + +one sink_4_1257( A&); +two sink_4_1257(const A&); +five sink_4_1257( A&&); +seven sink_4_1257(volatile A&&); + +int test4_1257() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1257(a)) == 1> t1; + sa<sizeof(sink_4_1257(ca)) == 2> t2; + sa<sizeof(sink_4_1257(va)) == 7> t3; + sa<sizeof(sink_4_1257(source())) == 5> t5; + sa<sizeof(sink_4_1257(c_source())) == 2> t6; + sa<sizeof(sink_4_1257(v_source())) == 7> t7; + return 0; +} + +one sink_4_1258( A&); +two sink_4_1258(const A&); +five sink_4_1258( A&&); +eight sink_4_1258(const volatile A&&); + +int test4_1258() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1258(a)) == 1> t1; + sa<sizeof(sink_4_1258(ca)) == 2> t2; + sa<sizeof(sink_4_1258(va)) == 8> t3; + sa<sizeof(sink_4_1258(cva)) == 8> t4; + sa<sizeof(sink_4_1258(source())) == 5> t5; + sa<sizeof(sink_4_1258(c_source())) == 8> t6; + sa<sizeof(sink_4_1258(v_source())) == 8> t7; + sa<sizeof(sink_4_1258(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1267( A&); +two sink_4_1267(const A&); +six sink_4_1267(const A&&); +seven sink_4_1267(volatile A&&); + +int test4_1267() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1267(a)) == 1> t1; + sa<sizeof(sink_4_1267(ca)) == 2> t2; + sa<sizeof(sink_4_1267(va)) == 7> t3; + sa<sizeof(sink_4_1267(c_source())) == 6> t6; + sa<sizeof(sink_4_1267(v_source())) == 7> t7; + return 0; +} + +one sink_4_1268( A&); +two sink_4_1268(const A&); +six sink_4_1268(const A&&); +eight sink_4_1268(const volatile A&&); + +int test4_1268() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1268(a)) == 1> t1; + sa<sizeof(sink_4_1268(ca)) == 2> t2; + sa<sizeof(sink_4_1268(va)) == 8> t3; + sa<sizeof(sink_4_1268(cva)) == 8> t4; + sa<sizeof(sink_4_1268(source())) == 6> t5; + sa<sizeof(sink_4_1268(c_source())) == 6> t6; + sa<sizeof(sink_4_1268(v_source())) == 8> t7; + sa<sizeof(sink_4_1268(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1278( A&); +two sink_4_1278(const A&); +seven sink_4_1278(volatile A&&); +eight sink_4_1278(const volatile A&&); + +int test4_1278() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1278(a)) == 1> t1; + sa<sizeof(sink_4_1278(ca)) == 2> t2; + sa<sizeof(sink_4_1278(va)) == 7> t3; + sa<sizeof(sink_4_1278(cva)) == 8> t4; + sa<sizeof(sink_4_1278(source())) == 7> t5; + sa<sizeof(sink_4_1278(c_source())) == 8> t6; + sa<sizeof(sink_4_1278(v_source())) == 7> t7; + sa<sizeof(sink_4_1278(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1345( A&); +three sink_4_1345(volatile A&); +four sink_4_1345(const volatile A&); +five sink_4_1345( A&&); + +int test4_1345() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1345(a)) == 1> t1; + sa<sizeof(sink_4_1345(ca)) == 4> t2; + sa<sizeof(sink_4_1345(va)) == 3> t3; + sa<sizeof(sink_4_1345(cva)) == 4> t4; + sa<sizeof(sink_4_1345(source())) == 5> t5; + return 0; +} + +one sink_4_1346( A&); +three sink_4_1346(volatile A&); +four sink_4_1346(const volatile A&); +six sink_4_1346(const A&&); + +int test4_1346() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1346(a)) == 1> t1; + sa<sizeof(sink_4_1346(ca)) == 4> t2; + sa<sizeof(sink_4_1346(va)) == 3> t3; + sa<sizeof(sink_4_1346(cva)) == 4> t4; + sa<sizeof(sink_4_1346(source())) == 6> t5; + sa<sizeof(sink_4_1346(c_source())) == 6> t6; + return 0; +} + +one sink_4_1347( A&); +three sink_4_1347(volatile A&); +four sink_4_1347(const volatile A&); +seven sink_4_1347(volatile A&&); + +int test4_1347() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1347(a)) == 1> t1; + sa<sizeof(sink_4_1347(ca)) == 4> t2; + sa<sizeof(sink_4_1347(va)) == 3> t3; + sa<sizeof(sink_4_1347(cva)) == 4> t4; + sa<sizeof(sink_4_1347(source())) == 7> t5; + sa<sizeof(sink_4_1347(v_source())) == 7> t7; + return 0; +} + +one sink_4_1348( A&); +three sink_4_1348(volatile A&); +four sink_4_1348(const volatile A&); +eight sink_4_1348(const volatile A&&); + +int test4_1348() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1348(a)) == 1> t1; + sa<sizeof(sink_4_1348(ca)) == 4> t2; + sa<sizeof(sink_4_1348(va)) == 3> t3; + sa<sizeof(sink_4_1348(cva)) == 4> t4; + sa<sizeof(sink_4_1348(source())) == 8> t5; + sa<sizeof(sink_4_1348(c_source())) == 8> t6; + sa<sizeof(sink_4_1348(v_source())) == 8> t7; + sa<sizeof(sink_4_1348(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1356( A&); +three sink_4_1356(volatile A&); +five sink_4_1356( A&&); +six sink_4_1356(const A&&); + +int test4_1356() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1356(a)) == 1> t1; + sa<sizeof(sink_4_1356(ca)) == 6> t2; + sa<sizeof(sink_4_1356(va)) == 3> t3; + sa<sizeof(sink_4_1356(source())) == 5> t5; + sa<sizeof(sink_4_1356(c_source())) == 6> t6; + return 0; +} + +one sink_4_1357( A&); +three sink_4_1357(volatile A&); +five sink_4_1357( A&&); +seven sink_4_1357(volatile A&&); + +int test4_1357() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1357(a)) == 1> t1; + sa<sizeof(sink_4_1357(va)) == 3> t3; + sa<sizeof(sink_4_1357(source())) == 5> t5; + sa<sizeof(sink_4_1357(v_source())) == 7> t7; + return 0; +} + +one sink_4_1358( A&); +three sink_4_1358(volatile A&); +five sink_4_1358( A&&); +eight sink_4_1358(const volatile A&&); + +int test4_1358() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1358(a)) == 1> t1; + sa<sizeof(sink_4_1358(ca)) == 8> t2; + sa<sizeof(sink_4_1358(va)) == 3> t3; + sa<sizeof(sink_4_1358(cva)) == 8> t4; + sa<sizeof(sink_4_1358(source())) == 5> t5; + sa<sizeof(sink_4_1358(c_source())) == 8> t6; + sa<sizeof(sink_4_1358(v_source())) == 8> t7; + sa<sizeof(sink_4_1358(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1367( A&); +three sink_4_1367(volatile A&); +six sink_4_1367(const A&&); +seven sink_4_1367(volatile A&&); + +int test4_1367() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1367(a)) == 1> t1; + sa<sizeof(sink_4_1367(ca)) == 6> t2; + sa<sizeof(sink_4_1367(va)) == 3> t3; + sa<sizeof(sink_4_1367(c_source())) == 6> t6; + sa<sizeof(sink_4_1367(v_source())) == 7> t7; + return 0; +} + +one sink_4_1368( A&); +three sink_4_1368(volatile A&); +six sink_4_1368(const A&&); +eight sink_4_1368(const volatile A&&); + +int test4_1368() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1368(a)) == 1> t1; + sa<sizeof(sink_4_1368(ca)) == 6> t2; + sa<sizeof(sink_4_1368(va)) == 3> t3; + sa<sizeof(sink_4_1368(cva)) == 8> t4; + sa<sizeof(sink_4_1368(source())) == 6> t5; + sa<sizeof(sink_4_1368(c_source())) == 6> t6; + sa<sizeof(sink_4_1368(v_source())) == 8> t7; + sa<sizeof(sink_4_1368(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1378( A&); +three sink_4_1378(volatile A&); +seven sink_4_1378(volatile A&&); +eight sink_4_1378(const volatile A&&); + +int test4_1378() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1378(a)) == 1> t1; + sa<sizeof(sink_4_1378(ca)) == 8> t2; + sa<sizeof(sink_4_1378(va)) == 3> t3; + sa<sizeof(sink_4_1378(cva)) == 8> t4; + sa<sizeof(sink_4_1378(source())) == 7> t5; + sa<sizeof(sink_4_1378(c_source())) == 8> t6; + sa<sizeof(sink_4_1378(v_source())) == 7> t7; + sa<sizeof(sink_4_1378(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1456( A&); +four sink_4_1456(const volatile A&); +five sink_4_1456( A&&); +six sink_4_1456(const A&&); + +int test4_1456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1456(a)) == 1> t1; + sa<sizeof(sink_4_1456(ca)) == 4> t2; + sa<sizeof(sink_4_1456(va)) == 4> t3; + sa<sizeof(sink_4_1456(cva)) == 4> t4; + sa<sizeof(sink_4_1456(source())) == 5> t5; + sa<sizeof(sink_4_1456(c_source())) == 6> t6; + return 0; +} + +one sink_4_1457( A&); +four sink_4_1457(const volatile A&); +five sink_4_1457( A&&); +seven sink_4_1457(volatile A&&); + +int test4_1457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1457(a)) == 1> t1; + sa<sizeof(sink_4_1457(ca)) == 4> t2; + sa<sizeof(sink_4_1457(va)) == 4> t3; + sa<sizeof(sink_4_1457(cva)) == 4> t4; + sa<sizeof(sink_4_1457(source())) == 5> t5; + sa<sizeof(sink_4_1457(v_source())) == 7> t7; + return 0; +} + +one sink_4_1458( A&); +four sink_4_1458(const volatile A&); +five sink_4_1458( A&&); +eight sink_4_1458(const volatile A&&); + +int test4_1458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1458(a)) == 1> t1; + sa<sizeof(sink_4_1458(ca)) == 4> t2; + sa<sizeof(sink_4_1458(va)) == 4> t3; + sa<sizeof(sink_4_1458(cva)) == 4> t4; + sa<sizeof(sink_4_1458(source())) == 5> t5; + sa<sizeof(sink_4_1458(c_source())) == 8> t6; + sa<sizeof(sink_4_1458(v_source())) == 8> t7; + sa<sizeof(sink_4_1458(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1467( A&); +four sink_4_1467(const volatile A&); +six sink_4_1467(const A&&); +seven sink_4_1467(volatile A&&); + +int test4_1467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1467(a)) == 1> t1; + sa<sizeof(sink_4_1467(ca)) == 4> t2; + sa<sizeof(sink_4_1467(va)) == 4> t3; + sa<sizeof(sink_4_1467(cva)) == 4> t4; + sa<sizeof(sink_4_1467(c_source())) == 6> t6; + sa<sizeof(sink_4_1467(v_source())) == 7> t7; + return 0; +} + +one sink_4_1468( A&); +four sink_4_1468(const volatile A&); +six sink_4_1468(const A&&); +eight sink_4_1468(const volatile A&&); + +int test4_1468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1468(a)) == 1> t1; + sa<sizeof(sink_4_1468(ca)) == 4> t2; + sa<sizeof(sink_4_1468(va)) == 4> t3; + sa<sizeof(sink_4_1468(cva)) == 4> t4; + sa<sizeof(sink_4_1468(source())) == 6> t5; + sa<sizeof(sink_4_1468(c_source())) == 6> t6; + sa<sizeof(sink_4_1468(v_source())) == 8> t7; + sa<sizeof(sink_4_1468(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1478( A&); +four sink_4_1478(const volatile A&); +seven sink_4_1478(volatile A&&); +eight sink_4_1478(const volatile A&&); + +int test4_1478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1478(a)) == 1> t1; + sa<sizeof(sink_4_1478(ca)) == 4> t2; + sa<sizeof(sink_4_1478(va)) == 4> t3; + sa<sizeof(sink_4_1478(cva)) == 4> t4; + sa<sizeof(sink_4_1478(source())) == 7> t5; + sa<sizeof(sink_4_1478(c_source())) == 8> t6; + sa<sizeof(sink_4_1478(v_source())) == 7> t7; + sa<sizeof(sink_4_1478(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1567( A&); +five sink_4_1567( A&&); +six sink_4_1567(const A&&); +seven sink_4_1567(volatile A&&); + +int test4_1567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1567(a)) == 1> t1; + sa<sizeof(sink_4_1567(ca)) == 6> t2; + sa<sizeof(sink_4_1567(va)) == 7> t3; + sa<sizeof(sink_4_1567(source())) == 5> t5; + sa<sizeof(sink_4_1567(c_source())) == 6> t6; + sa<sizeof(sink_4_1567(v_source())) == 7> t7; + return 0; +} + +one sink_4_1568( A&); +five sink_4_1568( A&&); +six sink_4_1568(const A&&); +eight sink_4_1568(const volatile A&&); + +int test4_1568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1568(a)) == 1> t1; + sa<sizeof(sink_4_1568(ca)) == 6> t2; + sa<sizeof(sink_4_1568(va)) == 8> t3; + sa<sizeof(sink_4_1568(cva)) == 8> t4; + sa<sizeof(sink_4_1568(source())) == 5> t5; + sa<sizeof(sink_4_1568(c_source())) == 6> t6; + sa<sizeof(sink_4_1568(v_source())) == 8> t7; + sa<sizeof(sink_4_1568(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1578( A&); +five sink_4_1578( A&&); +seven sink_4_1578(volatile A&&); +eight sink_4_1578(const volatile A&&); + +int test4_1578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1578(a)) == 1> t1; + sa<sizeof(sink_4_1578(ca)) == 8> t2; + sa<sizeof(sink_4_1578(va)) == 7> t3; + sa<sizeof(sink_4_1578(cva)) == 8> t4; + sa<sizeof(sink_4_1578(source())) == 5> t5; + sa<sizeof(sink_4_1578(c_source())) == 8> t6; + sa<sizeof(sink_4_1578(v_source())) == 7> t7; + sa<sizeof(sink_4_1578(cv_source())) == 8> t8; + return 0; +} + +one sink_4_1678( A&); +six sink_4_1678(const A&&); +seven sink_4_1678(volatile A&&); +eight sink_4_1678(const volatile A&&); + +int test4_1678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_1678(a)) == 1> t1; + sa<sizeof(sink_4_1678(ca)) == 6> t2; + sa<sizeof(sink_4_1678(va)) == 7> t3; + sa<sizeof(sink_4_1678(cva)) == 8> t4; + sa<sizeof(sink_4_1678(c_source())) == 6> t6; + sa<sizeof(sink_4_1678(v_source())) == 7> t7; + sa<sizeof(sink_4_1678(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2345(const A&); +three sink_4_2345(volatile A&); +four sink_4_2345(const volatile A&); +five sink_4_2345( A&&); + +int test4_2345() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2345(ca)) == 2> t2; + sa<sizeof(sink_4_2345(va)) == 3> t3; + sa<sizeof(sink_4_2345(cva)) == 4> t4; + sa<sizeof(sink_4_2345(source())) == 5> t5; + sa<sizeof(sink_4_2345(c_source())) == 2> t6; + return 0; +} + +two sink_4_2346(const A&); +three sink_4_2346(volatile A&); +four sink_4_2346(const volatile A&); +six sink_4_2346(const A&&); + +int test4_2346() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2346(ca)) == 2> t2; + sa<sizeof(sink_4_2346(va)) == 3> t3; + sa<sizeof(sink_4_2346(cva)) == 4> t4; + sa<sizeof(sink_4_2346(source())) == 6> t5; + sa<sizeof(sink_4_2346(c_source())) == 6> t6; + return 0; +} + +two sink_4_2347(const A&); +three sink_4_2347(volatile A&); +four sink_4_2347(const volatile A&); +seven sink_4_2347(volatile A&&); + +int test4_2347() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2347(ca)) == 2> t2; + sa<sizeof(sink_4_2347(va)) == 3> t3; + sa<sizeof(sink_4_2347(cva)) == 4> t4; + sa<sizeof(sink_4_2347(source())) == 7> t5; + sa<sizeof(sink_4_2347(c_source())) == 2> t6; + sa<sizeof(sink_4_2347(v_source())) == 7> t7; + return 0; +} + +two sink_4_2348(const A&); +three sink_4_2348(volatile A&); +four sink_4_2348(const volatile A&); +eight sink_4_2348(const volatile A&&); + +int test4_2348() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2348(ca)) == 2> t2; + sa<sizeof(sink_4_2348(va)) == 3> t3; + sa<sizeof(sink_4_2348(cva)) == 4> t4; + sa<sizeof(sink_4_2348(source())) == 8> t5; + sa<sizeof(sink_4_2348(c_source())) == 8> t6; + sa<sizeof(sink_4_2348(v_source())) == 8> t7; + sa<sizeof(sink_4_2348(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2356(const A&); +three sink_4_2356(volatile A&); +five sink_4_2356( A&&); +six sink_4_2356(const A&&); + +int test4_2356() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2356(ca)) == 2> t2; + sa<sizeof(sink_4_2356(va)) == 3> t3; + sa<sizeof(sink_4_2356(source())) == 5> t5; + sa<sizeof(sink_4_2356(c_source())) == 6> t6; + return 0; +} + +two sink_4_2357(const A&); +three sink_4_2357(volatile A&); +five sink_4_2357( A&&); +seven sink_4_2357(volatile A&&); + +int test4_2357() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2357(ca)) == 2> t2; + sa<sizeof(sink_4_2357(va)) == 3> t3; + sa<sizeof(sink_4_2357(source())) == 5> t5; + sa<sizeof(sink_4_2357(c_source())) == 2> t6; + sa<sizeof(sink_4_2357(v_source())) == 7> t7; + return 0; +} + +two sink_4_2358(const A&); +three sink_4_2358(volatile A&); +five sink_4_2358( A&&); +eight sink_4_2358(const volatile A&&); + +int test4_2358() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2358(ca)) == 2> t2; + sa<sizeof(sink_4_2358(va)) == 3> t3; + sa<sizeof(sink_4_2358(cva)) == 8> t4; + sa<sizeof(sink_4_2358(source())) == 5> t5; + sa<sizeof(sink_4_2358(c_source())) == 8> t6; + sa<sizeof(sink_4_2358(v_source())) == 8> t7; + sa<sizeof(sink_4_2358(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2367(const A&); +three sink_4_2367(volatile A&); +six sink_4_2367(const A&&); +seven sink_4_2367(volatile A&&); + +int test4_2367() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2367(ca)) == 2> t2; + sa<sizeof(sink_4_2367(va)) == 3> t3; + sa<sizeof(sink_4_2367(c_source())) == 6> t6; + sa<sizeof(sink_4_2367(v_source())) == 7> t7; + return 0; +} + +two sink_4_2368(const A&); +three sink_4_2368(volatile A&); +six sink_4_2368(const A&&); +eight sink_4_2368(const volatile A&&); + +int test4_2368() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2368(ca)) == 2> t2; + sa<sizeof(sink_4_2368(va)) == 3> t3; + sa<sizeof(sink_4_2368(cva)) == 8> t4; + sa<sizeof(sink_4_2368(source())) == 6> t5; + sa<sizeof(sink_4_2368(c_source())) == 6> t6; + sa<sizeof(sink_4_2368(v_source())) == 8> t7; + sa<sizeof(sink_4_2368(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2378(const A&); +three sink_4_2378(volatile A&); +seven sink_4_2378(volatile A&&); +eight sink_4_2378(const volatile A&&); + +int test4_2378() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2378(ca)) == 2> t2; + sa<sizeof(sink_4_2378(va)) == 3> t3; + sa<sizeof(sink_4_2378(cva)) == 8> t4; + sa<sizeof(sink_4_2378(source())) == 7> t5; + sa<sizeof(sink_4_2378(c_source())) == 8> t6; + sa<sizeof(sink_4_2378(v_source())) == 7> t7; + sa<sizeof(sink_4_2378(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2456(const A&); +four sink_4_2456(const volatile A&); +five sink_4_2456( A&&); +six sink_4_2456(const A&&); + +int test4_2456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2456(a)) == 2> t1; + sa<sizeof(sink_4_2456(ca)) == 2> t2; + sa<sizeof(sink_4_2456(va)) == 4> t3; + sa<sizeof(sink_4_2456(cva)) == 4> t4; + sa<sizeof(sink_4_2456(source())) == 5> t5; + sa<sizeof(sink_4_2456(c_source())) == 6> t6; + return 0; +} + +two sink_4_2457(const A&); +four sink_4_2457(const volatile A&); +five sink_4_2457( A&&); +seven sink_4_2457(volatile A&&); + +int test4_2457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2457(a)) == 2> t1; + sa<sizeof(sink_4_2457(ca)) == 2> t2; + sa<sizeof(sink_4_2457(va)) == 4> t3; + sa<sizeof(sink_4_2457(cva)) == 4> t4; + sa<sizeof(sink_4_2457(source())) == 5> t5; + sa<sizeof(sink_4_2457(c_source())) == 2> t6; + sa<sizeof(sink_4_2457(v_source())) == 7> t7; + return 0; +} + +two sink_4_2458(const A&); +four sink_4_2458(const volatile A&); +five sink_4_2458( A&&); +eight sink_4_2458(const volatile A&&); + +int test4_2458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2458(a)) == 2> t1; + sa<sizeof(sink_4_2458(ca)) == 2> t2; + sa<sizeof(sink_4_2458(va)) == 4> t3; + sa<sizeof(sink_4_2458(cva)) == 4> t4; + sa<sizeof(sink_4_2458(source())) == 5> t5; + sa<sizeof(sink_4_2458(c_source())) == 8> t6; + sa<sizeof(sink_4_2458(v_source())) == 8> t7; + sa<sizeof(sink_4_2458(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2467(const A&); +four sink_4_2467(const volatile A&); +six sink_4_2467(const A&&); +seven sink_4_2467(volatile A&&); + +int test4_2467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2467(a)) == 2> t1; + sa<sizeof(sink_4_2467(ca)) == 2> t2; + sa<sizeof(sink_4_2467(va)) == 4> t3; + sa<sizeof(sink_4_2467(cva)) == 4> t4; + sa<sizeof(sink_4_2467(c_source())) == 6> t6; + sa<sizeof(sink_4_2467(v_source())) == 7> t7; + return 0; +} + +two sink_4_2468(const A&); +four sink_4_2468(const volatile A&); +six sink_4_2468(const A&&); +eight sink_4_2468(const volatile A&&); + +int test4_2468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2468(a)) == 2> t1; + sa<sizeof(sink_4_2468(ca)) == 2> t2; + sa<sizeof(sink_4_2468(va)) == 4> t3; + sa<sizeof(sink_4_2468(cva)) == 4> t4; + sa<sizeof(sink_4_2468(source())) == 6> t5; + sa<sizeof(sink_4_2468(c_source())) == 6> t6; + sa<sizeof(sink_4_2468(v_source())) == 8> t7; + sa<sizeof(sink_4_2468(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2478(const A&); +four sink_4_2478(const volatile A&); +seven sink_4_2478(volatile A&&); +eight sink_4_2478(const volatile A&&); + +int test4_2478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2478(a)) == 2> t1; + sa<sizeof(sink_4_2478(ca)) == 2> t2; + sa<sizeof(sink_4_2478(va)) == 4> t3; + sa<sizeof(sink_4_2478(cva)) == 4> t4; + sa<sizeof(sink_4_2478(source())) == 7> t5; + sa<sizeof(sink_4_2478(c_source())) == 8> t6; + sa<sizeof(sink_4_2478(v_source())) == 7> t7; + sa<sizeof(sink_4_2478(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2567(const A&); +five sink_4_2567( A&&); +six sink_4_2567(const A&&); +seven sink_4_2567(volatile A&&); + +int test4_2567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2567(a)) == 2> t1; + sa<sizeof(sink_4_2567(ca)) == 2> t2; + sa<sizeof(sink_4_2567(va)) == 7> t3; + sa<sizeof(sink_4_2567(source())) == 5> t5; + sa<sizeof(sink_4_2567(c_source())) == 6> t6; + sa<sizeof(sink_4_2567(v_source())) == 7> t7; + return 0; +} + +two sink_4_2568(const A&); +five sink_4_2568( A&&); +six sink_4_2568(const A&&); +eight sink_4_2568(const volatile A&&); + +int test4_2568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2568(a)) == 2> t1; + sa<sizeof(sink_4_2568(ca)) == 2> t2; + sa<sizeof(sink_4_2568(va)) == 8> t3; + sa<sizeof(sink_4_2568(cva)) == 8> t4; + sa<sizeof(sink_4_2568(source())) == 5> t5; + sa<sizeof(sink_4_2568(c_source())) == 6> t6; + sa<sizeof(sink_4_2568(v_source())) == 8> t7; + sa<sizeof(sink_4_2568(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2578(const A&); +five sink_4_2578( A&&); +seven sink_4_2578(volatile A&&); +eight sink_4_2578(const volatile A&&); + +int test4_2578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2578(a)) == 2> t1; + sa<sizeof(sink_4_2578(ca)) == 2> t2; + sa<sizeof(sink_4_2578(va)) == 7> t3; + sa<sizeof(sink_4_2578(cva)) == 8> t4; + sa<sizeof(sink_4_2578(source())) == 5> t5; + sa<sizeof(sink_4_2578(c_source())) == 8> t6; + sa<sizeof(sink_4_2578(v_source())) == 7> t7; + sa<sizeof(sink_4_2578(cv_source())) == 8> t8; + return 0; +} + +two sink_4_2678(const A&); +six sink_4_2678(const A&&); +seven sink_4_2678(volatile A&&); +eight sink_4_2678(const volatile A&&); + +int test4_2678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_2678(a)) == 2> t1; + sa<sizeof(sink_4_2678(ca)) == 2> t2; + sa<sizeof(sink_4_2678(va)) == 7> t3; + sa<sizeof(sink_4_2678(cva)) == 8> t4; + sa<sizeof(sink_4_2678(c_source())) == 6> t6; + sa<sizeof(sink_4_2678(v_source())) == 7> t7; + sa<sizeof(sink_4_2678(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3456(volatile A&); +four sink_4_3456(const volatile A&); +five sink_4_3456( A&&); +six sink_4_3456(const A&&); + +int test4_3456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3456(a)) == 3> t1; + sa<sizeof(sink_4_3456(ca)) == 4> t2; + sa<sizeof(sink_4_3456(va)) == 3> t3; + sa<sizeof(sink_4_3456(cva)) == 4> t4; + sa<sizeof(sink_4_3456(source())) == 5> t5; + sa<sizeof(sink_4_3456(c_source())) == 6> t6; + return 0; +} + +three sink_4_3457(volatile A&); +four sink_4_3457(const volatile A&); +five sink_4_3457( A&&); +seven sink_4_3457(volatile A&&); + +int test4_3457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3457(a)) == 3> t1; + sa<sizeof(sink_4_3457(ca)) == 4> t2; + sa<sizeof(sink_4_3457(va)) == 3> t3; + sa<sizeof(sink_4_3457(cva)) == 4> t4; + sa<sizeof(sink_4_3457(source())) == 5> t5; + sa<sizeof(sink_4_3457(v_source())) == 7> t7; + return 0; +} + +three sink_4_3458(volatile A&); +four sink_4_3458(const volatile A&); +five sink_4_3458( A&&); +eight sink_4_3458(const volatile A&&); + +int test4_3458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3458(a)) == 3> t1; + sa<sizeof(sink_4_3458(ca)) == 4> t2; + sa<sizeof(sink_4_3458(va)) == 3> t3; + sa<sizeof(sink_4_3458(cva)) == 4> t4; + sa<sizeof(sink_4_3458(source())) == 5> t5; + sa<sizeof(sink_4_3458(c_source())) == 8> t6; + sa<sizeof(sink_4_3458(v_source())) == 8> t7; + sa<sizeof(sink_4_3458(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3467(volatile A&); +four sink_4_3467(const volatile A&); +six sink_4_3467(const A&&); +seven sink_4_3467(volatile A&&); + +int test4_3467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3467(a)) == 3> t1; + sa<sizeof(sink_4_3467(ca)) == 4> t2; + sa<sizeof(sink_4_3467(va)) == 3> t3; + sa<sizeof(sink_4_3467(cva)) == 4> t4; + sa<sizeof(sink_4_3467(c_source())) == 6> t6; + sa<sizeof(sink_4_3467(v_source())) == 7> t7; + return 0; +} + +three sink_4_3468(volatile A&); +four sink_4_3468(const volatile A&); +six sink_4_3468(const A&&); +eight sink_4_3468(const volatile A&&); + +int test4_3468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3468(a)) == 3> t1; + sa<sizeof(sink_4_3468(ca)) == 4> t2; + sa<sizeof(sink_4_3468(va)) == 3> t3; + sa<sizeof(sink_4_3468(cva)) == 4> t4; + sa<sizeof(sink_4_3468(source())) == 6> t5; + sa<sizeof(sink_4_3468(c_source())) == 6> t6; + sa<sizeof(sink_4_3468(v_source())) == 8> t7; + sa<sizeof(sink_4_3468(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3478(volatile A&); +four sink_4_3478(const volatile A&); +seven sink_4_3478(volatile A&&); +eight sink_4_3478(const volatile A&&); + +int test4_3478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3478(a)) == 3> t1; + sa<sizeof(sink_4_3478(ca)) == 4> t2; + sa<sizeof(sink_4_3478(va)) == 3> t3; + sa<sizeof(sink_4_3478(cva)) == 4> t4; + sa<sizeof(sink_4_3478(source())) == 7> t5; + sa<sizeof(sink_4_3478(c_source())) == 8> t6; + sa<sizeof(sink_4_3478(v_source())) == 7> t7; + sa<sizeof(sink_4_3478(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3567(volatile A&); +five sink_4_3567( A&&); +six sink_4_3567(const A&&); +seven sink_4_3567(volatile A&&); + +int test4_3567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3567(a)) == 3> t1; + sa<sizeof(sink_4_3567(ca)) == 6> t2; + sa<sizeof(sink_4_3567(va)) == 3> t3; + sa<sizeof(sink_4_3567(source())) == 5> t5; + sa<sizeof(sink_4_3567(c_source())) == 6> t6; + sa<sizeof(sink_4_3567(v_source())) == 7> t7; + return 0; +} + +three sink_4_3568(volatile A&); +five sink_4_3568( A&&); +six sink_4_3568(const A&&); +eight sink_4_3568(const volatile A&&); + +int test4_3568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3568(a)) == 3> t1; + sa<sizeof(sink_4_3568(ca)) == 6> t2; + sa<sizeof(sink_4_3568(va)) == 3> t3; + sa<sizeof(sink_4_3568(cva)) == 8> t4; + sa<sizeof(sink_4_3568(source())) == 5> t5; + sa<sizeof(sink_4_3568(c_source())) == 6> t6; + sa<sizeof(sink_4_3568(v_source())) == 8> t7; + sa<sizeof(sink_4_3568(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3578(volatile A&); +five sink_4_3578( A&&); +seven sink_4_3578(volatile A&&); +eight sink_4_3578(const volatile A&&); + +int test4_3578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3578(a)) == 3> t1; + sa<sizeof(sink_4_3578(ca)) == 8> t2; + sa<sizeof(sink_4_3578(va)) == 3> t3; + sa<sizeof(sink_4_3578(cva)) == 8> t4; + sa<sizeof(sink_4_3578(source())) == 5> t5; + sa<sizeof(sink_4_3578(c_source())) == 8> t6; + sa<sizeof(sink_4_3578(v_source())) == 7> t7; + sa<sizeof(sink_4_3578(cv_source())) == 8> t8; + return 0; +} + +three sink_4_3678(volatile A&); +six sink_4_3678(const A&&); +seven sink_4_3678(volatile A&&); +eight sink_4_3678(const volatile A&&); + +int test4_3678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_3678(a)) == 3> t1; + sa<sizeof(sink_4_3678(ca)) == 6> t2; + sa<sizeof(sink_4_3678(va)) == 3> t3; + sa<sizeof(sink_4_3678(cva)) == 8> t4; + sa<sizeof(sink_4_3678(c_source())) == 6> t6; + sa<sizeof(sink_4_3678(v_source())) == 7> t7; + sa<sizeof(sink_4_3678(cv_source())) == 8> t8; + return 0; +} + +four sink_4_4567(const volatile A&); +five sink_4_4567( A&&); +six sink_4_4567(const A&&); +seven sink_4_4567(volatile A&&); + +int test4_4567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_4567(a)) == 4> t1; + sa<sizeof(sink_4_4567(ca)) == 4> t2; + sa<sizeof(sink_4_4567(va)) == 4> t3; + sa<sizeof(sink_4_4567(cva)) == 4> t4; + sa<sizeof(sink_4_4567(source())) == 5> t5; + sa<sizeof(sink_4_4567(c_source())) == 6> t6; + sa<sizeof(sink_4_4567(v_source())) == 7> t7; + return 0; +} + +four sink_4_4568(const volatile A&); +five sink_4_4568( A&&); +six sink_4_4568(const A&&); +eight sink_4_4568(const volatile A&&); + +int test4_4568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_4568(a)) == 4> t1; + sa<sizeof(sink_4_4568(ca)) == 4> t2; + sa<sizeof(sink_4_4568(va)) == 4> t3; + sa<sizeof(sink_4_4568(cva)) == 4> t4; + sa<sizeof(sink_4_4568(source())) == 5> t5; + sa<sizeof(sink_4_4568(c_source())) == 6> t6; + sa<sizeof(sink_4_4568(v_source())) == 8> t7; + sa<sizeof(sink_4_4568(cv_source())) == 8> t8; + return 0; +} + +four sink_4_4578(const volatile A&); +five sink_4_4578( A&&); +seven sink_4_4578(volatile A&&); +eight sink_4_4578(const volatile A&&); + +int test4_4578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_4578(a)) == 4> t1; + sa<sizeof(sink_4_4578(ca)) == 4> t2; + sa<sizeof(sink_4_4578(va)) == 4> t3; + sa<sizeof(sink_4_4578(cva)) == 4> t4; + sa<sizeof(sink_4_4578(source())) == 5> t5; + sa<sizeof(sink_4_4578(c_source())) == 8> t6; + sa<sizeof(sink_4_4578(v_source())) == 7> t7; + sa<sizeof(sink_4_4578(cv_source())) == 8> t8; + return 0; +} + +four sink_4_4678(const volatile A&); +six sink_4_4678(const A&&); +seven sink_4_4678(volatile A&&); +eight sink_4_4678(const volatile A&&); + +int test4_4678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_4678(a)) == 4> t1; + sa<sizeof(sink_4_4678(ca)) == 4> t2; + sa<sizeof(sink_4_4678(va)) == 4> t3; + sa<sizeof(sink_4_4678(cva)) == 4> t4; + sa<sizeof(sink_4_4678(c_source())) == 6> t6; + sa<sizeof(sink_4_4678(v_source())) == 7> t7; + sa<sizeof(sink_4_4678(cv_source())) == 8> t8; + return 0; +} + +five sink_4_5678( A&&); +six sink_4_5678(const A&&); +seven sink_4_5678(volatile A&&); +eight sink_4_5678(const volatile A&&); + +int test4_5678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_4_5678(a)) == 5> t1; + sa<sizeof(sink_4_5678(ca)) == 6> t2; + sa<sizeof(sink_4_5678(va)) == 7> t3; + sa<sizeof(sink_4_5678(cva)) == 8> t4; + sa<sizeof(sink_4_5678(source())) == 5> t5; + sa<sizeof(sink_4_5678(c_source())) == 6> t6; + sa<sizeof(sink_4_5678(v_source())) == 7> t7; + sa<sizeof(sink_4_5678(cv_source())) == 8> t8; + return 0; +} + +int main() +{ + return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() + + test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() + + test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() + + test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() + + test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() + + test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() + + test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() + + test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() + + test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() + + test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() + + test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() + + test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() + + test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() + + test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv5n.C b/gcc/testsuite/g++.dg/cpp0x/rv5n.C new file mode 100644 index 0000000..715716e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv5n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv5p.C b/gcc/testsuite/g++.dg/cpp0x/rv5p.C new file mode 100644 index 0000000..a4d9167 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv5p.C @@ -0,0 +1,1283 @@ +// 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&); +two sink_5_12345(const A&); +three sink_5_12345(volatile A&); +four sink_5_12345(const volatile A&); +five sink_5_12345( A&&); + +int test5_12345() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12345(a)) == 1> t1; + sa<sizeof(sink_5_12345(ca)) == 2> t2; + sa<sizeof(sink_5_12345(va)) == 3> t3; + sa<sizeof(sink_5_12345(cva)) == 4> t4; + sa<sizeof(sink_5_12345(source())) == 5> t5; + sa<sizeof(sink_5_12345(c_source())) == 2> t6; + return 0; +} + +one sink_5_12346( A&); +two sink_5_12346(const A&); +three sink_5_12346(volatile A&); +four sink_5_12346(const volatile A&); +six sink_5_12346(const A&&); + +int test5_12346() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12346(a)) == 1> t1; + sa<sizeof(sink_5_12346(ca)) == 2> t2; + sa<sizeof(sink_5_12346(va)) == 3> t3; + sa<sizeof(sink_5_12346(cva)) == 4> t4; + sa<sizeof(sink_5_12346(source())) == 6> t5; + sa<sizeof(sink_5_12346(c_source())) == 6> t6; + return 0; +} + +one sink_5_12347( A&); +two sink_5_12347(const A&); +three sink_5_12347(volatile A&); +four sink_5_12347(const volatile A&); +seven sink_5_12347(volatile A&&); + +int test5_12347() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12347(a)) == 1> t1; + sa<sizeof(sink_5_12347(ca)) == 2> t2; + sa<sizeof(sink_5_12347(va)) == 3> t3; + sa<sizeof(sink_5_12347(cva)) == 4> t4; + sa<sizeof(sink_5_12347(source())) == 7> t5; + sa<sizeof(sink_5_12347(c_source())) == 2> t6; + sa<sizeof(sink_5_12347(v_source())) == 7> t7; + return 0; +} + +one sink_5_12348( A&); +two sink_5_12348(const A&); +three sink_5_12348(volatile A&); +four sink_5_12348(const volatile A&); +eight sink_5_12348(const volatile A&&); + +int test5_12348() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12348(a)) == 1> t1; + sa<sizeof(sink_5_12348(ca)) == 2> t2; + sa<sizeof(sink_5_12348(va)) == 3> t3; + sa<sizeof(sink_5_12348(cva)) == 4> t4; + sa<sizeof(sink_5_12348(source())) == 8> t5; + sa<sizeof(sink_5_12348(c_source())) == 8> t6; + sa<sizeof(sink_5_12348(v_source())) == 8> t7; + sa<sizeof(sink_5_12348(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12356( A&); +two sink_5_12356(const A&); +three sink_5_12356(volatile A&); +five sink_5_12356( A&&); +six sink_5_12356(const A&&); + +int test5_12356() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12356(a)) == 1> t1; + sa<sizeof(sink_5_12356(ca)) == 2> t2; + sa<sizeof(sink_5_12356(va)) == 3> t3; + sa<sizeof(sink_5_12356(source())) == 5> t5; + sa<sizeof(sink_5_12356(c_source())) == 6> t6; + return 0; +} + +one sink_5_12357( A&); +two sink_5_12357(const A&); +three sink_5_12357(volatile A&); +five sink_5_12357( A&&); +seven sink_5_12357(volatile A&&); + +int test5_12357() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12357(a)) == 1> t1; + sa<sizeof(sink_5_12357(ca)) == 2> t2; + sa<sizeof(sink_5_12357(va)) == 3> t3; + sa<sizeof(sink_5_12357(source())) == 5> t5; + sa<sizeof(sink_5_12357(c_source())) == 2> t6; + sa<sizeof(sink_5_12357(v_source())) == 7> t7; + return 0; +} + +one sink_5_12358( A&); +two sink_5_12358(const A&); +three sink_5_12358(volatile A&); +five sink_5_12358( A&&); +eight sink_5_12358(const volatile A&&); + +int test5_12358() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12358(a)) == 1> t1; + sa<sizeof(sink_5_12358(ca)) == 2> t2; + sa<sizeof(sink_5_12358(va)) == 3> t3; + sa<sizeof(sink_5_12358(cva)) == 8> t4; + sa<sizeof(sink_5_12358(source())) == 5> t5; + sa<sizeof(sink_5_12358(c_source())) == 8> t6; + sa<sizeof(sink_5_12358(v_source())) == 8> t7; + sa<sizeof(sink_5_12358(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12367( A&); +two sink_5_12367(const A&); +three sink_5_12367(volatile A&); +six sink_5_12367(const A&&); +seven sink_5_12367(volatile A&&); + +int test5_12367() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12367(a)) == 1> t1; + sa<sizeof(sink_5_12367(ca)) == 2> t2; + sa<sizeof(sink_5_12367(va)) == 3> t3; + sa<sizeof(sink_5_12367(c_source())) == 6> t6; + sa<sizeof(sink_5_12367(v_source())) == 7> t7; + return 0; +} + +one sink_5_12368( A&); +two sink_5_12368(const A&); +three sink_5_12368(volatile A&); +six sink_5_12368(const A&&); +eight sink_5_12368(const volatile A&&); + +int test5_12368() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12368(a)) == 1> t1; + sa<sizeof(sink_5_12368(ca)) == 2> t2; + sa<sizeof(sink_5_12368(va)) == 3> t3; + sa<sizeof(sink_5_12368(cva)) == 8> t4; + sa<sizeof(sink_5_12368(source())) == 6> t5; + sa<sizeof(sink_5_12368(c_source())) == 6> t6; + sa<sizeof(sink_5_12368(v_source())) == 8> t7; + sa<sizeof(sink_5_12368(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12378( A&); +two sink_5_12378(const A&); +three sink_5_12378(volatile A&); +seven sink_5_12378(volatile A&&); +eight sink_5_12378(const volatile A&&); + +int test5_12378() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12378(a)) == 1> t1; + sa<sizeof(sink_5_12378(ca)) == 2> t2; + sa<sizeof(sink_5_12378(va)) == 3> t3; + sa<sizeof(sink_5_12378(cva)) == 8> t4; + sa<sizeof(sink_5_12378(source())) == 7> t5; + sa<sizeof(sink_5_12378(c_source())) == 8> t6; + sa<sizeof(sink_5_12378(v_source())) == 7> t7; + sa<sizeof(sink_5_12378(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12456( A&); +two sink_5_12456(const A&); +four sink_5_12456(const volatile A&); +five sink_5_12456( A&&); +six sink_5_12456(const A&&); + +int test5_12456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12456(a)) == 1> t1; + sa<sizeof(sink_5_12456(ca)) == 2> t2; + sa<sizeof(sink_5_12456(va)) == 4> t3; + sa<sizeof(sink_5_12456(cva)) == 4> t4; + sa<sizeof(sink_5_12456(source())) == 5> t5; + sa<sizeof(sink_5_12456(c_source())) == 6> t6; + return 0; +} + +one sink_5_12457( A&); +two sink_5_12457(const A&); +four sink_5_12457(const volatile A&); +five sink_5_12457( A&&); +seven sink_5_12457(volatile A&&); + +int test5_12457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12457(a)) == 1> t1; + sa<sizeof(sink_5_12457(ca)) == 2> t2; + sa<sizeof(sink_5_12457(va)) == 4> t3; + sa<sizeof(sink_5_12457(cva)) == 4> t4; + sa<sizeof(sink_5_12457(source())) == 5> t5; + sa<sizeof(sink_5_12457(c_source())) == 2> t6; + sa<sizeof(sink_5_12457(v_source())) == 7> t7; + return 0; +} + +one sink_5_12458( A&); +two sink_5_12458(const A&); +four sink_5_12458(const volatile A&); +five sink_5_12458( A&&); +eight sink_5_12458(const volatile A&&); + +int test5_12458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12458(a)) == 1> t1; + sa<sizeof(sink_5_12458(ca)) == 2> t2; + sa<sizeof(sink_5_12458(va)) == 4> t3; + sa<sizeof(sink_5_12458(cva)) == 4> t4; + sa<sizeof(sink_5_12458(source())) == 5> t5; + sa<sizeof(sink_5_12458(c_source())) == 8> t6; + sa<sizeof(sink_5_12458(v_source())) == 8> t7; + sa<sizeof(sink_5_12458(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12467( A&); +two sink_5_12467(const A&); +four sink_5_12467(const volatile A&); +six sink_5_12467(const A&&); +seven sink_5_12467(volatile A&&); + +int test5_12467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12467(a)) == 1> t1; + sa<sizeof(sink_5_12467(ca)) == 2> t2; + sa<sizeof(sink_5_12467(va)) == 4> t3; + sa<sizeof(sink_5_12467(cva)) == 4> t4; + sa<sizeof(sink_5_12467(c_source())) == 6> t6; + sa<sizeof(sink_5_12467(v_source())) == 7> t7; + return 0; +} + +one sink_5_12468( A&); +two sink_5_12468(const A&); +four sink_5_12468(const volatile A&); +six sink_5_12468(const A&&); +eight sink_5_12468(const volatile A&&); + +int test5_12468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12468(a)) == 1> t1; + sa<sizeof(sink_5_12468(ca)) == 2> t2; + sa<sizeof(sink_5_12468(va)) == 4> t3; + sa<sizeof(sink_5_12468(cva)) == 4> t4; + sa<sizeof(sink_5_12468(source())) == 6> t5; + sa<sizeof(sink_5_12468(c_source())) == 6> t6; + sa<sizeof(sink_5_12468(v_source())) == 8> t7; + sa<sizeof(sink_5_12468(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12478( A&); +two sink_5_12478(const A&); +four sink_5_12478(const volatile A&); +seven sink_5_12478(volatile A&&); +eight sink_5_12478(const volatile A&&); + +int test5_12478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12478(a)) == 1> t1; + sa<sizeof(sink_5_12478(ca)) == 2> t2; + sa<sizeof(sink_5_12478(va)) == 4> t3; + sa<sizeof(sink_5_12478(cva)) == 4> t4; + sa<sizeof(sink_5_12478(source())) == 7> t5; + sa<sizeof(sink_5_12478(c_source())) == 8> t6; + sa<sizeof(sink_5_12478(v_source())) == 7> t7; + sa<sizeof(sink_5_12478(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12567( A&); +two sink_5_12567(const A&); +five sink_5_12567( A&&); +six sink_5_12567(const A&&); +seven sink_5_12567(volatile A&&); + +int test5_12567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12567(a)) == 1> t1; + sa<sizeof(sink_5_12567(ca)) == 2> t2; + sa<sizeof(sink_5_12567(va)) == 7> t3; + sa<sizeof(sink_5_12567(source())) == 5> t5; + sa<sizeof(sink_5_12567(c_source())) == 6> t6; + sa<sizeof(sink_5_12567(v_source())) == 7> t7; + return 0; +} + +one sink_5_12568( A&); +two sink_5_12568(const A&); +five sink_5_12568( A&&); +six sink_5_12568(const A&&); +eight sink_5_12568(const volatile A&&); + +int test5_12568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12568(a)) == 1> t1; + sa<sizeof(sink_5_12568(ca)) == 2> t2; + sa<sizeof(sink_5_12568(va)) == 8> t3; + sa<sizeof(sink_5_12568(cva)) == 8> t4; + sa<sizeof(sink_5_12568(source())) == 5> t5; + sa<sizeof(sink_5_12568(c_source())) == 6> t6; + sa<sizeof(sink_5_12568(v_source())) == 8> t7; + sa<sizeof(sink_5_12568(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12578( A&); +two sink_5_12578(const A&); +five sink_5_12578( A&&); +seven sink_5_12578(volatile A&&); +eight sink_5_12578(const volatile A&&); + +int test5_12578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12578(a)) == 1> t1; + sa<sizeof(sink_5_12578(ca)) == 2> t2; + sa<sizeof(sink_5_12578(va)) == 7> t3; + sa<sizeof(sink_5_12578(cva)) == 8> t4; + sa<sizeof(sink_5_12578(source())) == 5> t5; + sa<sizeof(sink_5_12578(c_source())) == 8> t6; + sa<sizeof(sink_5_12578(v_source())) == 7> t7; + sa<sizeof(sink_5_12578(cv_source())) == 8> t8; + return 0; +} + +one sink_5_12678( A&); +two sink_5_12678(const A&); +six sink_5_12678(const A&&); +seven sink_5_12678(volatile A&&); +eight sink_5_12678(const volatile A&&); + +int test5_12678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_12678(a)) == 1> t1; + sa<sizeof(sink_5_12678(ca)) == 2> t2; + sa<sizeof(sink_5_12678(va)) == 7> t3; + sa<sizeof(sink_5_12678(cva)) == 8> t4; + sa<sizeof(sink_5_12678(c_source())) == 6> t6; + sa<sizeof(sink_5_12678(v_source())) == 7> t7; + sa<sizeof(sink_5_12678(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13456( A&); +three sink_5_13456(volatile A&); +four sink_5_13456(const volatile A&); +five sink_5_13456( A&&); +six sink_5_13456(const A&&); + +int test5_13456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13456(a)) == 1> t1; + sa<sizeof(sink_5_13456(ca)) == 4> t2; + sa<sizeof(sink_5_13456(va)) == 3> t3; + sa<sizeof(sink_5_13456(cva)) == 4> t4; + sa<sizeof(sink_5_13456(source())) == 5> t5; + sa<sizeof(sink_5_13456(c_source())) == 6> t6; + return 0; +} + +one sink_5_13457( A&); +three sink_5_13457(volatile A&); +four sink_5_13457(const volatile A&); +five sink_5_13457( A&&); +seven sink_5_13457(volatile A&&); + +int test5_13457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13457(a)) == 1> t1; + sa<sizeof(sink_5_13457(ca)) == 4> t2; + sa<sizeof(sink_5_13457(va)) == 3> t3; + sa<sizeof(sink_5_13457(cva)) == 4> t4; + sa<sizeof(sink_5_13457(source())) == 5> t5; + sa<sizeof(sink_5_13457(v_source())) == 7> t7; + return 0; +} + +one sink_5_13458( A&); +three sink_5_13458(volatile A&); +four sink_5_13458(const volatile A&); +five sink_5_13458( A&&); +eight sink_5_13458(const volatile A&&); + +int test5_13458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13458(a)) == 1> t1; + sa<sizeof(sink_5_13458(ca)) == 4> t2; + sa<sizeof(sink_5_13458(va)) == 3> t3; + sa<sizeof(sink_5_13458(cva)) == 4> t4; + sa<sizeof(sink_5_13458(source())) == 5> t5; + sa<sizeof(sink_5_13458(c_source())) == 8> t6; + sa<sizeof(sink_5_13458(v_source())) == 8> t7; + sa<sizeof(sink_5_13458(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13467( A&); +three sink_5_13467(volatile A&); +four sink_5_13467(const volatile A&); +six sink_5_13467(const A&&); +seven sink_5_13467(volatile A&&); + +int test5_13467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13467(a)) == 1> t1; + sa<sizeof(sink_5_13467(ca)) == 4> t2; + sa<sizeof(sink_5_13467(va)) == 3> t3; + sa<sizeof(sink_5_13467(cva)) == 4> t4; + sa<sizeof(sink_5_13467(c_source())) == 6> t6; + sa<sizeof(sink_5_13467(v_source())) == 7> t7; + return 0; +} + +one sink_5_13468( A&); +three sink_5_13468(volatile A&); +four sink_5_13468(const volatile A&); +six sink_5_13468(const A&&); +eight sink_5_13468(const volatile A&&); + +int test5_13468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13468(a)) == 1> t1; + sa<sizeof(sink_5_13468(ca)) == 4> t2; + sa<sizeof(sink_5_13468(va)) == 3> t3; + sa<sizeof(sink_5_13468(cva)) == 4> t4; + sa<sizeof(sink_5_13468(source())) == 6> t5; + sa<sizeof(sink_5_13468(c_source())) == 6> t6; + sa<sizeof(sink_5_13468(v_source())) == 8> t7; + sa<sizeof(sink_5_13468(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13478( A&); +three sink_5_13478(volatile A&); +four sink_5_13478(const volatile A&); +seven sink_5_13478(volatile A&&); +eight sink_5_13478(const volatile A&&); + +int test5_13478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13478(a)) == 1> t1; + sa<sizeof(sink_5_13478(ca)) == 4> t2; + sa<sizeof(sink_5_13478(va)) == 3> t3; + sa<sizeof(sink_5_13478(cva)) == 4> t4; + sa<sizeof(sink_5_13478(source())) == 7> t5; + sa<sizeof(sink_5_13478(c_source())) == 8> t6; + sa<sizeof(sink_5_13478(v_source())) == 7> t7; + sa<sizeof(sink_5_13478(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13567( A&); +three sink_5_13567(volatile A&); +five sink_5_13567( A&&); +six sink_5_13567(const A&&); +seven sink_5_13567(volatile A&&); + +int test5_13567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13567(a)) == 1> t1; + sa<sizeof(sink_5_13567(ca)) == 6> t2; + sa<sizeof(sink_5_13567(va)) == 3> t3; + sa<sizeof(sink_5_13567(source())) == 5> t5; + sa<sizeof(sink_5_13567(c_source())) == 6> t6; + sa<sizeof(sink_5_13567(v_source())) == 7> t7; + return 0; +} + +one sink_5_13568( A&); +three sink_5_13568(volatile A&); +five sink_5_13568( A&&); +six sink_5_13568(const A&&); +eight sink_5_13568(const volatile A&&); + +int test5_13568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13568(a)) == 1> t1; + sa<sizeof(sink_5_13568(ca)) == 6> t2; + sa<sizeof(sink_5_13568(va)) == 3> t3; + sa<sizeof(sink_5_13568(cva)) == 8> t4; + sa<sizeof(sink_5_13568(source())) == 5> t5; + sa<sizeof(sink_5_13568(c_source())) == 6> t6; + sa<sizeof(sink_5_13568(v_source())) == 8> t7; + sa<sizeof(sink_5_13568(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13578( A&); +three sink_5_13578(volatile A&); +five sink_5_13578( A&&); +seven sink_5_13578(volatile A&&); +eight sink_5_13578(const volatile A&&); + +int test5_13578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13578(a)) == 1> t1; + sa<sizeof(sink_5_13578(ca)) == 8> t2; + sa<sizeof(sink_5_13578(va)) == 3> t3; + sa<sizeof(sink_5_13578(cva)) == 8> t4; + sa<sizeof(sink_5_13578(source())) == 5> t5; + sa<sizeof(sink_5_13578(c_source())) == 8> t6; + sa<sizeof(sink_5_13578(v_source())) == 7> t7; + sa<sizeof(sink_5_13578(cv_source())) == 8> t8; + return 0; +} + +one sink_5_13678( A&); +three sink_5_13678(volatile A&); +six sink_5_13678(const A&&); +seven sink_5_13678(volatile A&&); +eight sink_5_13678(const volatile A&&); + +int test5_13678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_13678(a)) == 1> t1; + sa<sizeof(sink_5_13678(ca)) == 6> t2; + sa<sizeof(sink_5_13678(va)) == 3> t3; + sa<sizeof(sink_5_13678(cva)) == 8> t4; + sa<sizeof(sink_5_13678(c_source())) == 6> t6; + sa<sizeof(sink_5_13678(v_source())) == 7> t7; + sa<sizeof(sink_5_13678(cv_source())) == 8> t8; + return 0; +} + +one sink_5_14567( A&); +four sink_5_14567(const volatile A&); +five sink_5_14567( A&&); +six sink_5_14567(const A&&); +seven sink_5_14567(volatile A&&); + +int test5_14567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_14567(a)) == 1> t1; + sa<sizeof(sink_5_14567(ca)) == 4> t2; + sa<sizeof(sink_5_14567(va)) == 4> t3; + sa<sizeof(sink_5_14567(cva)) == 4> t4; + sa<sizeof(sink_5_14567(source())) == 5> t5; + sa<sizeof(sink_5_14567(c_source())) == 6> t6; + sa<sizeof(sink_5_14567(v_source())) == 7> t7; + return 0; +} + +one sink_5_14568( A&); +four sink_5_14568(const volatile A&); +five sink_5_14568( A&&); +six sink_5_14568(const A&&); +eight sink_5_14568(const volatile A&&); + +int test5_14568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_14568(a)) == 1> t1; + sa<sizeof(sink_5_14568(ca)) == 4> t2; + sa<sizeof(sink_5_14568(va)) == 4> t3; + sa<sizeof(sink_5_14568(cva)) == 4> t4; + sa<sizeof(sink_5_14568(source())) == 5> t5; + sa<sizeof(sink_5_14568(c_source())) == 6> t6; + sa<sizeof(sink_5_14568(v_source())) == 8> t7; + sa<sizeof(sink_5_14568(cv_source())) == 8> t8; + return 0; +} + +one sink_5_14578( A&); +four sink_5_14578(const volatile A&); +five sink_5_14578( A&&); +seven sink_5_14578(volatile A&&); +eight sink_5_14578(const volatile A&&); + +int test5_14578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_14578(a)) == 1> t1; + sa<sizeof(sink_5_14578(ca)) == 4> t2; + sa<sizeof(sink_5_14578(va)) == 4> t3; + sa<sizeof(sink_5_14578(cva)) == 4> t4; + sa<sizeof(sink_5_14578(source())) == 5> t5; + sa<sizeof(sink_5_14578(c_source())) == 8> t6; + sa<sizeof(sink_5_14578(v_source())) == 7> t7; + sa<sizeof(sink_5_14578(cv_source())) == 8> t8; + return 0; +} + +one sink_5_14678( A&); +four sink_5_14678(const volatile A&); +six sink_5_14678(const A&&); +seven sink_5_14678(volatile A&&); +eight sink_5_14678(const volatile A&&); + +int test5_14678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_14678(a)) == 1> t1; + sa<sizeof(sink_5_14678(ca)) == 4> t2; + sa<sizeof(sink_5_14678(va)) == 4> t3; + sa<sizeof(sink_5_14678(cva)) == 4> t4; + sa<sizeof(sink_5_14678(c_source())) == 6> t6; + sa<sizeof(sink_5_14678(v_source())) == 7> t7; + sa<sizeof(sink_5_14678(cv_source())) == 8> t8; + return 0; +} + +one sink_5_15678( A&); +five sink_5_15678( A&&); +six sink_5_15678(const A&&); +seven sink_5_15678(volatile A&&); +eight sink_5_15678(const volatile A&&); + +int test5_15678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_15678(a)) == 1> t1; + sa<sizeof(sink_5_15678(ca)) == 6> t2; + sa<sizeof(sink_5_15678(va)) == 7> t3; + sa<sizeof(sink_5_15678(cva)) == 8> t4; + sa<sizeof(sink_5_15678(source())) == 5> t5; + sa<sizeof(sink_5_15678(c_source())) == 6> t6; + sa<sizeof(sink_5_15678(v_source())) == 7> t7; + sa<sizeof(sink_5_15678(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23456(const A&); +three sink_5_23456(volatile A&); +four sink_5_23456(const volatile A&); +five sink_5_23456( A&&); +six sink_5_23456(const A&&); + +int test5_23456() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23456(ca)) == 2> t2; + sa<sizeof(sink_5_23456(va)) == 3> t3; + sa<sizeof(sink_5_23456(cva)) == 4> t4; + sa<sizeof(sink_5_23456(source())) == 5> t5; + sa<sizeof(sink_5_23456(c_source())) == 6> t6; + return 0; +} + +two sink_5_23457(const A&); +three sink_5_23457(volatile A&); +four sink_5_23457(const volatile A&); +five sink_5_23457( A&&); +seven sink_5_23457(volatile A&&); + +int test5_23457() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23457(ca)) == 2> t2; + sa<sizeof(sink_5_23457(va)) == 3> t3; + sa<sizeof(sink_5_23457(cva)) == 4> t4; + sa<sizeof(sink_5_23457(source())) == 5> t5; + sa<sizeof(sink_5_23457(c_source())) == 2> t6; + sa<sizeof(sink_5_23457(v_source())) == 7> t7; + return 0; +} + +two sink_5_23458(const A&); +three sink_5_23458(volatile A&); +four sink_5_23458(const volatile A&); +five sink_5_23458( A&&); +eight sink_5_23458(const volatile A&&); + +int test5_23458() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23458(ca)) == 2> t2; + sa<sizeof(sink_5_23458(va)) == 3> t3; + sa<sizeof(sink_5_23458(cva)) == 4> t4; + sa<sizeof(sink_5_23458(source())) == 5> t5; + sa<sizeof(sink_5_23458(c_source())) == 8> t6; + sa<sizeof(sink_5_23458(v_source())) == 8> t7; + sa<sizeof(sink_5_23458(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23467(const A&); +three sink_5_23467(volatile A&); +four sink_5_23467(const volatile A&); +six sink_5_23467(const A&&); +seven sink_5_23467(volatile A&&); + +int test5_23467() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23467(ca)) == 2> t2; + sa<sizeof(sink_5_23467(va)) == 3> t3; + sa<sizeof(sink_5_23467(cva)) == 4> t4; + sa<sizeof(sink_5_23467(c_source())) == 6> t6; + sa<sizeof(sink_5_23467(v_source())) == 7> t7; + return 0; +} + +two sink_5_23468(const A&); +three sink_5_23468(volatile A&); +four sink_5_23468(const volatile A&); +six sink_5_23468(const A&&); +eight sink_5_23468(const volatile A&&); + +int test5_23468() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23468(ca)) == 2> t2; + sa<sizeof(sink_5_23468(va)) == 3> t3; + sa<sizeof(sink_5_23468(cva)) == 4> t4; + sa<sizeof(sink_5_23468(source())) == 6> t5; + sa<sizeof(sink_5_23468(c_source())) == 6> t6; + sa<sizeof(sink_5_23468(v_source())) == 8> t7; + sa<sizeof(sink_5_23468(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23478(const A&); +three sink_5_23478(volatile A&); +four sink_5_23478(const volatile A&); +seven sink_5_23478(volatile A&&); +eight sink_5_23478(const volatile A&&); + +int test5_23478() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23478(ca)) == 2> t2; + sa<sizeof(sink_5_23478(va)) == 3> t3; + sa<sizeof(sink_5_23478(cva)) == 4> t4; + sa<sizeof(sink_5_23478(source())) == 7> t5; + sa<sizeof(sink_5_23478(c_source())) == 8> t6; + sa<sizeof(sink_5_23478(v_source())) == 7> t7; + sa<sizeof(sink_5_23478(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23567(const A&); +three sink_5_23567(volatile A&); +five sink_5_23567( A&&); +six sink_5_23567(const A&&); +seven sink_5_23567(volatile A&&); + +int test5_23567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23567(ca)) == 2> t2; + sa<sizeof(sink_5_23567(va)) == 3> t3; + sa<sizeof(sink_5_23567(source())) == 5> t5; + sa<sizeof(sink_5_23567(c_source())) == 6> t6; + sa<sizeof(sink_5_23567(v_source())) == 7> t7; + return 0; +} + +two sink_5_23568(const A&); +three sink_5_23568(volatile A&); +five sink_5_23568( A&&); +six sink_5_23568(const A&&); +eight sink_5_23568(const volatile A&&); + +int test5_23568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23568(ca)) == 2> t2; + sa<sizeof(sink_5_23568(va)) == 3> t3; + sa<sizeof(sink_5_23568(cva)) == 8> t4; + sa<sizeof(sink_5_23568(source())) == 5> t5; + sa<sizeof(sink_5_23568(c_source())) == 6> t6; + sa<sizeof(sink_5_23568(v_source())) == 8> t7; + sa<sizeof(sink_5_23568(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23578(const A&); +three sink_5_23578(volatile A&); +five sink_5_23578( A&&); +seven sink_5_23578(volatile A&&); +eight sink_5_23578(const volatile A&&); + +int test5_23578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23578(ca)) == 2> t2; + sa<sizeof(sink_5_23578(va)) == 3> t3; + sa<sizeof(sink_5_23578(cva)) == 8> t4; + sa<sizeof(sink_5_23578(source())) == 5> t5; + sa<sizeof(sink_5_23578(c_source())) == 8> t6; + sa<sizeof(sink_5_23578(v_source())) == 7> t7; + sa<sizeof(sink_5_23578(cv_source())) == 8> t8; + return 0; +} + +two sink_5_23678(const A&); +three sink_5_23678(volatile A&); +six sink_5_23678(const A&&); +seven sink_5_23678(volatile A&&); +eight sink_5_23678(const volatile A&&); + +int test5_23678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_23678(ca)) == 2> t2; + sa<sizeof(sink_5_23678(va)) == 3> t3; + sa<sizeof(sink_5_23678(cva)) == 8> t4; + sa<sizeof(sink_5_23678(c_source())) == 6> t6; + sa<sizeof(sink_5_23678(v_source())) == 7> t7; + sa<sizeof(sink_5_23678(cv_source())) == 8> t8; + return 0; +} + +two sink_5_24567(const A&); +four sink_5_24567(const volatile A&); +five sink_5_24567( A&&); +six sink_5_24567(const A&&); +seven sink_5_24567(volatile A&&); + +int test5_24567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_24567(a)) == 2> t1; + sa<sizeof(sink_5_24567(ca)) == 2> t2; + sa<sizeof(sink_5_24567(va)) == 4> t3; + sa<sizeof(sink_5_24567(cva)) == 4> t4; + sa<sizeof(sink_5_24567(source())) == 5> t5; + sa<sizeof(sink_5_24567(c_source())) == 6> t6; + sa<sizeof(sink_5_24567(v_source())) == 7> t7; + return 0; +} + +two sink_5_24568(const A&); +four sink_5_24568(const volatile A&); +five sink_5_24568( A&&); +six sink_5_24568(const A&&); +eight sink_5_24568(const volatile A&&); + +int test5_24568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_24568(a)) == 2> t1; + sa<sizeof(sink_5_24568(ca)) == 2> t2; + sa<sizeof(sink_5_24568(va)) == 4> t3; + sa<sizeof(sink_5_24568(cva)) == 4> t4; + sa<sizeof(sink_5_24568(source())) == 5> t5; + sa<sizeof(sink_5_24568(c_source())) == 6> t6; + sa<sizeof(sink_5_24568(v_source())) == 8> t7; + sa<sizeof(sink_5_24568(cv_source())) == 8> t8; + return 0; +} + +two sink_5_24578(const A&); +four sink_5_24578(const volatile A&); +five sink_5_24578( A&&); +seven sink_5_24578(volatile A&&); +eight sink_5_24578(const volatile A&&); + +int test5_24578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_24578(a)) == 2> t1; + sa<sizeof(sink_5_24578(ca)) == 2> t2; + sa<sizeof(sink_5_24578(va)) == 4> t3; + sa<sizeof(sink_5_24578(cva)) == 4> t4; + sa<sizeof(sink_5_24578(source())) == 5> t5; + sa<sizeof(sink_5_24578(c_source())) == 8> t6; + sa<sizeof(sink_5_24578(v_source())) == 7> t7; + sa<sizeof(sink_5_24578(cv_source())) == 8> t8; + return 0; +} + +two sink_5_24678(const A&); +four sink_5_24678(const volatile A&); +six sink_5_24678(const A&&); +seven sink_5_24678(volatile A&&); +eight sink_5_24678(const volatile A&&); + +int test5_24678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_24678(a)) == 2> t1; + sa<sizeof(sink_5_24678(ca)) == 2> t2; + sa<sizeof(sink_5_24678(va)) == 4> t3; + sa<sizeof(sink_5_24678(cva)) == 4> t4; + sa<sizeof(sink_5_24678(c_source())) == 6> t6; + sa<sizeof(sink_5_24678(v_source())) == 7> t7; + sa<sizeof(sink_5_24678(cv_source())) == 8> t8; + return 0; +} + +two sink_5_25678(const A&); +five sink_5_25678( A&&); +six sink_5_25678(const A&&); +seven sink_5_25678(volatile A&&); +eight sink_5_25678(const volatile A&&); + +int test5_25678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_25678(a)) == 2> t1; + sa<sizeof(sink_5_25678(ca)) == 2> t2; + sa<sizeof(sink_5_25678(va)) == 7> t3; + sa<sizeof(sink_5_25678(cva)) == 8> t4; + sa<sizeof(sink_5_25678(source())) == 5> t5; + sa<sizeof(sink_5_25678(c_source())) == 6> t6; + sa<sizeof(sink_5_25678(v_source())) == 7> t7; + sa<sizeof(sink_5_25678(cv_source())) == 8> t8; + return 0; +} + +three sink_5_34567(volatile A&); +four sink_5_34567(const volatile A&); +five sink_5_34567( A&&); +six sink_5_34567(const A&&); +seven sink_5_34567(volatile A&&); + +int test5_34567() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_34567(a)) == 3> t1; + sa<sizeof(sink_5_34567(ca)) == 4> t2; + sa<sizeof(sink_5_34567(va)) == 3> t3; + sa<sizeof(sink_5_34567(cva)) == 4> t4; + sa<sizeof(sink_5_34567(source())) == 5> t5; + sa<sizeof(sink_5_34567(c_source())) == 6> t6; + sa<sizeof(sink_5_34567(v_source())) == 7> t7; + return 0; +} + +three sink_5_34568(volatile A&); +four sink_5_34568(const volatile A&); +five sink_5_34568( A&&); +six sink_5_34568(const A&&); +eight sink_5_34568(const volatile A&&); + +int test5_34568() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_34568(a)) == 3> t1; + sa<sizeof(sink_5_34568(ca)) == 4> t2; + sa<sizeof(sink_5_34568(va)) == 3> t3; + sa<sizeof(sink_5_34568(cva)) == 4> t4; + sa<sizeof(sink_5_34568(source())) == 5> t5; + sa<sizeof(sink_5_34568(c_source())) == 6> t6; + sa<sizeof(sink_5_34568(v_source())) == 8> t7; + sa<sizeof(sink_5_34568(cv_source())) == 8> t8; + return 0; +} + +three sink_5_34578(volatile A&); +four sink_5_34578(const volatile A&); +five sink_5_34578( A&&); +seven sink_5_34578(volatile A&&); +eight sink_5_34578(const volatile A&&); + +int test5_34578() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_34578(a)) == 3> t1; + sa<sizeof(sink_5_34578(ca)) == 4> t2; + sa<sizeof(sink_5_34578(va)) == 3> t3; + sa<sizeof(sink_5_34578(cva)) == 4> t4; + sa<sizeof(sink_5_34578(source())) == 5> t5; + sa<sizeof(sink_5_34578(c_source())) == 8> t6; + sa<sizeof(sink_5_34578(v_source())) == 7> t7; + sa<sizeof(sink_5_34578(cv_source())) == 8> t8; + return 0; +} + +three sink_5_34678(volatile A&); +four sink_5_34678(const volatile A&); +six sink_5_34678(const A&&); +seven sink_5_34678(volatile A&&); +eight sink_5_34678(const volatile A&&); + +int test5_34678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_34678(a)) == 3> t1; + sa<sizeof(sink_5_34678(ca)) == 4> t2; + sa<sizeof(sink_5_34678(va)) == 3> t3; + sa<sizeof(sink_5_34678(cva)) == 4> t4; + sa<sizeof(sink_5_34678(c_source())) == 6> t6; + sa<sizeof(sink_5_34678(v_source())) == 7> t7; + sa<sizeof(sink_5_34678(cv_source())) == 8> t8; + return 0; +} + +three sink_5_35678(volatile A&); +five sink_5_35678( A&&); +six sink_5_35678(const A&&); +seven sink_5_35678(volatile A&&); +eight sink_5_35678(const volatile A&&); + +int test5_35678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_35678(a)) == 3> t1; + sa<sizeof(sink_5_35678(ca)) == 6> t2; + sa<sizeof(sink_5_35678(va)) == 3> t3; + sa<sizeof(sink_5_35678(cva)) == 8> t4; + sa<sizeof(sink_5_35678(source())) == 5> t5; + sa<sizeof(sink_5_35678(c_source())) == 6> t6; + sa<sizeof(sink_5_35678(v_source())) == 7> t7; + sa<sizeof(sink_5_35678(cv_source())) == 8> t8; + return 0; +} + +four sink_5_45678(const volatile A&); +five sink_5_45678( A&&); +six sink_5_45678(const A&&); +seven sink_5_45678(volatile A&&); +eight sink_5_45678(const volatile A&&); + +int test5_45678() +{ + A a; + const A ca = a; + volatile A va; + const volatile A cva = a; + sa<sizeof(sink_5_45678(a)) == 4> t1; + sa<sizeof(sink_5_45678(ca)) == 4> t2; + sa<sizeof(sink_5_45678(va)) == 4> t3; + sa<sizeof(sink_5_45678(cva)) == 4> t4; + sa<sizeof(sink_5_45678(source())) == 5> t5; + sa<sizeof(sink_5_45678(c_source())) == 6> t6; + sa<sizeof(sink_5_45678(v_source())) == 7> t7; + sa<sizeof(sink_5_45678(cv_source())) == 8> t8; + return 0; +} + +int main() +{ + return test5_12345() + test5_12346() + test5_12347() + test5_12348() + + test5_12356() + test5_12357() + test5_12358() + test5_12367() + + test5_12368() + test5_12378() + test5_12456() + test5_12457() + + test5_12458() + test5_12467() + test5_12468() + test5_12478() + + test5_12567() + test5_12568() + test5_12578() + test5_12678() + + test5_13456() + test5_13457() + test5_13458() + test5_13467() + + test5_13468() + test5_13478() + test5_13567() + test5_13568() + + test5_13578() + test5_13678() + test5_14567() + test5_14568() + + test5_14578() + test5_14678() + test5_15678() + test5_23456() + + test5_23457() + test5_23458() + test5_23467() + test5_23468() + + test5_23478() + test5_23567() + test5_23568() + test5_23578() + + test5_23678() + test5_24567() + test5_24568() + test5_24578() + + test5_24678() + test5_25678() + test5_34567() + test5_34568() + + test5_34578() + test5_34678() + test5_35678() + test5_45678(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv6n.C b/gcc/testsuite/g++.dg/cpp0x/rv6n.C new file mode 100644 index 0000000..9a925ef --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv6n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv6p.C b/gcc/testsuite/g++.dg/cpp0x/rv6p.C new file mode 100644 index 0000000..a59958e --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv6p.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv7n.C b/gcc/testsuite/g++.dg/cpp0x/rv7n.C new file mode 100644 index 0000000..acd884b --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv7n.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv7p.C b/gcc/testsuite/g++.dg/cpp0x/rv7p.C new file mode 100644 index 0000000..d3e1474 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv7p.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rv8p.C b/gcc/testsuite/g++.dg/cpp0x/rv8p.C new file mode 100644 index 0000000..95a72d5 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rv8p.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/rvo.C b/gcc/testsuite/g++.dg/cpp0x/rvo.C new file mode 100644 index 0000000..b52ce74 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/rvo.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/temp-constructor-bug.C b/gcc/testsuite/g++.dg/cpp0x/temp-constructor-bug.C new file mode 100644 index 0000000..a067207 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/temp-constructor-bug.C @@ -0,0 +1,15 @@ +// { dg-options "--std=c++0x" } + +struct S { }; + +struct T +{ + S s; +}; + +void f(T const &); + +void g() +{ + f((T){S()}); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/temp-va-arg-bug.C b/gcc/testsuite/g++.dg/cpp0x/temp-va-arg-bug.C new file mode 100644 index 0000000..5314b24 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/temp-va-arg-bug.C @@ -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)); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/template_deduction.C b/gcc/testsuite/g++.dg/cpp0x/template_deduction.C new file mode 100644 index 0000000..ee48fb3 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/template_deduction.C @@ -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; +} diff --git a/gcc/testsuite/g++.dg/cpp0x/unnamed_refs.C b/gcc/testsuite/g++.dg/cpp0x/unnamed_refs.C new file mode 100644 index 0000000..0631185 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/unnamed_refs.C @@ -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(); +} diff --git a/gcc/testsuite/g++.dg/init/copy7.C b/gcc/testsuite/g++.dg/init/copy7.C index 0f60437..8c23c54 100644 --- a/gcc/testsuite/g++.dg/init/copy7.C +++ b/gcc/testsuite/g++.dg/init/copy7.C @@ -1,3 +1,4 @@ +// { dg-options "-std=c++98" } // PR c++/12226 class foo { diff --git a/gcc/testsuite/g++.dg/overload/arg1.C b/gcc/testsuite/g++.dg/overload/arg1.C index 6ac6a7e..ba0f6f0 100644 --- a/gcc/testsuite/g++.dg/overload/arg1.C +++ b/gcc/testsuite/g++.dg/overload/arg1.C @@ -1,3 +1,4 @@ +// { dg-options "-std=c++98" } // { dg-do compile } // Copyright (C) 2004 Free Software Foundation, Inc. diff --git a/gcc/testsuite/g++.dg/overload/arg4.C b/gcc/testsuite/g++.dg/overload/arg4.C index 34aa625..1461928 100644 --- a/gcc/testsuite/g++.dg/overload/arg4.C +++ b/gcc/testsuite/g++.dg/overload/arg4.C @@ -1,3 +1,4 @@ +// { dg-options "-std=c++98" } // { dg-do compile } // Copyright (C) 2004 Free Software Foundation, Inc. |