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 23 class foo; 24 25 typedef foo &foo_lval_ref; 26 typedef foo &&foo_rval_ref; 27 28 class foo 29 { 30 public: 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 42 void 43 marker1 () 44 { 45 } 46 47 static int 48 f (int &x) 49 { 50 return 1; 51 } 52 53 static int 54 f (const int &x) 55 { 56 return 2; 57 } 58 59 static int 60 f (int &&x) 61 { 62 return 3; 63 } 64 65 static int 66 g (int &&x) 67 { 68 return x; 69 } 70 71 int 72 main () 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 97 foo::foo () {} 98 foo::foo (foo_lval_ref afoo) {} 99 foo::foo (foo_rval_ref afoo) {} 100 foo::~foo () {} 101 102 /* Some functions to test overloading by varying one argument type. */ 103 104 int foo::overload1arg (foo_lval_ref arg) { return 1; } 105 int foo::overload1arg (foo_rval_ref arg) { return 2; } 106 int foo::overloadConst (const foo &arg) { return 3; } 107 int foo::overloadConst (const foo &&arg) { return 4; } 108