1 /* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2014-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 #include <stdbool.h> 19 #include <iostream> 20 21 #define SOME_MACRO 23 22 #define ARG_MACRO(X, Y) ((X) + (Y) - 1) 23 24 25 enum enum_type { 26 ONE = 1, 27 TWO = 2 28 }; 29 30 typedef int v4 __attribute__ ((vector_size (16))); 31 32 union union_type; 33 34 struct struct_type { 35 char charfield; 36 unsigned char ucharfield; 37 short shortfield; 38 unsigned short ushortfield; 39 int intfield; 40 unsigned int uintfield; 41 unsigned int bitfield : 3; 42 long longfield; 43 unsigned long ulongfield; 44 enum enum_type enumfield; 45 float floatfield; 46 double doublefield; 47 const union union_type *ptrfield; 48 struct struct_type *selffield; 49 int arrayfield[5]; 50 _Complex double complexfield; 51 _Bool boolfield; 52 v4 vectorfield; 53 }; 54 55 typedef int inttypedef; 56 57 union union_type { 58 int intfield; 59 inttypedef typedeffield; 60 }; 61 62 /* volatile provides some coverage of the conversion code. */ 63 volatile struct struct_type struct_object; 64 65 union union_type union_object; 66 67 68 enum ulonger_enum_type { 69 REALLY_MINUS_1 = -1UL, 70 }; 71 72 enum ulonger_enum_type ulonger; 73 74 enum longer_enum_type { 75 MINUS_1 = -1, 76 FORCE_TO_LONG = 1L << ((8 * sizeof (long)) - 2) 77 }; 78 79 enum longer_enum_type longer; 80 81 int globalvar = 10; 82 83 static void 84 func_static (int addend) 85 { 86 globalvar += addend; 87 } 88 89 void 90 func_global (int subtrahend) 91 { 92 globalvar -= subtrahend; 93 } 94 95 void 96 no_args_or_locals () 97 { 98 /* no_args_or_locals breakpoint */ 99 } 100 101 int *intptr; 102 int globalshadow = 10; 103 static int staticshadow = 20; 104 int externed = 7; 105 106 class Base 107 { 108 virtual int pure_virt () = 0; 109 public: 110 int return_value () {return a;} 111 private: 112 int a = 1; 113 int b = 2; 114 }; 115 116 class Base2 117 { 118 virtual int non_pure () {return 84;} 119 public: 120 int return_value () {return b;} 121 private: 122 int a = 3; 123 int b = 4; 124 }; 125 126 class Base3 127 { 128 public: 129 int return_value () {return b;} 130 private: 131 int b = 5; 132 }; 133 134 135 class Multiple : public Base, public Base2 136 { 137 int pure_virt () 138 { 139 int a = Base::return_value (); 140 return a + 42; 141 } 142 }; 143 //struct foo { foo(); virtual ~foo(); }; struct bar : virtual foo { bar(); ~bar(); }; struct baz : bar {}; bar::bar() {} bar::~bar() {} bar t; baz u; 144 struct VirtualOnly 145 { 146 VirtualOnly(); 147 virtual ~VirtualOnly()=0; 148 }; 149 150 VirtualOnly::VirtualOnly () 151 { 152 } 153 154 VirtualOnly::~VirtualOnly () 155 { 156 } 157 158 struct VirtualBase : virtual VirtualOnly 159 { 160 int z = 22; 161 VirtualBase (); 162 ~VirtualBase (); 163 }; 164 165 struct VirtualBase2 : VirtualBase {}; 166 167 VirtualBase::VirtualBase () 168 { 169 z = 24; 170 } 171 172 VirtualBase::~VirtualBase () 173 { 174 z = 22; 175 } 176 177 class Foo 178 { 179 int var; 180 static const int public_static_var = 12; 181 182 private: 183 int private_var = 0; 184 int private_method (); 185 186 public: 187 int public_var = 0; 188 int public_method (); 189 void set_private_var (int); 190 }; 191 192 void Foo::set_private_var (int i) 193 { 194 private_var = i; 195 } 196 197 int Foo::private_method () 198 { 199 return private_var; 200 } 201 202 int Foo::public_method () 203 { 204 return public_var; 205 } 206 207 int 208 main () 209 { 210 int localvar = 50; 211 int shadowed = 51; 212 int bound = 3; 213 int unresolved = 10; 214 int globalshadow = 100; 215 int staticshadow = 200; 216 int externed = 9; 217 int f = 0; 218 int var = 0; 219 Foo foovar; 220 Multiple *multivar = new Multiple; 221 VirtualBase vbase; 222 VirtualBase2 vbase2; 223 static int static_local = 77000; 224 225 foovar.public_var = 42; 226 foovar.set_private_var (42); 227 multivar->Base2::return_value(); 228 { 229 int another_local = 7; 230 int shadowed = 52; 231 extern int unresolved; 232 extern int externed; 233 234 int vla[bound]; 235 236 func_static (0); /* break-here */ 237 no_args_or_locals (); 238 } 239 240 return 0; 241 } 242