1/* This testcase is part of GDB, the GNU debugger.
2
3   Copyright 1998-2020 Free Software Foundation, Inc.
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation; either version 3 of the License, or
8   (at your option) any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17
18/* Rvalue references overload tests for GDB, based on overload.cc.  */
19
20#include <stddef.h>
21#include <utility>
22
23class foo;
24
25typedef foo &foo_lval_ref;
26typedef foo &&foo_rval_ref;
27
28class foo
29{
30public:
31  foo ();
32  foo (foo_lval_ref);
33  foo (foo_rval_ref);
34  ~foo ();
35
36  int overload1arg (foo_lval_ref);
37  int overload1arg (foo_rval_ref);
38  int overloadConst (const foo &);
39  int overloadConst (const foo &&);
40};
41
42void
43marker1 ()
44{
45}
46
47static int
48f (int &x)
49{
50  return 1;
51}
52
53static int
54f (const int &x)
55{
56  return 2;
57}
58
59static int
60f (int &&x)
61{
62  return 3;
63}
64
65static int
66g (int &&x)
67{
68  return x;
69}
70
71int
72main ()
73{
74  foo foo_rr_instance1;
75  foo arg;
76  int i = 0;
77  const int ci = 0;
78
79  // result = 1 + 2 + 3 + 3 = 9
80  int result = f (i) + f (ci) + f (0) + f (std::move (i));
81
82  /* Overload resolution below requires both a CV-conversion
83     and reference conversion.  */
84  int test_const // = 3
85    = foo_rr_instance1.overloadConst (arg);
86
87  /* The statement below is illegal: cannot bind rvalue reference of
88     type 'int&&' to lvalue of type 'int'.
89
90     result = g (i); */
91  result = g (5); // this is OK
92
93  marker1 (); // marker1-returns-here
94  return result;
95}
96
97foo::foo  ()                       {}
98foo::foo  (foo_lval_ref afoo)      {}
99foo::foo  (foo_rval_ref afoo)      {}
100foo::~foo ()                       {}
101
102/* Some functions to test overloading by varying one argument type. */
103
104int foo::overload1arg (foo_lval_ref arg)           { return 1; }
105int foo::overload1arg (foo_rval_ref arg)           { return 2; }
106int foo::overloadConst (const foo &arg)            { return 3; }
107int foo::overloadConst (const foo &&arg)           { return 4; }
108