1 /* This testcase is part of GDB, the GNU debugger. 2 3 Copyright 2008-2019 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 <string.h> 19 20 struct s 21 { 22 int a; 23 int *b; 24 }; 25 26 struct ss 27 { 28 struct s a; 29 struct s b; 30 }; 31 32 struct arraystruct 33 { 34 int y; 35 struct s x[2]; 36 }; 37 38 struct ns { 39 const char *null_str; 40 int length; 41 }; 42 43 struct lazystring { 44 const char *lazy_str; 45 /* If -1, don't pass length to gdb.lazy_string(). */ 46 int len; 47 }; 48 49 struct hint_error { 50 int x; 51 }; 52 53 struct children_as_list { 54 int x; 55 }; 56 57 #ifdef __cplusplus 58 struct S : public s { 59 int zs; 60 }; 61 62 struct SS { 63 int zss; 64 S s; 65 }; 66 67 struct SSS 68 { 69 SSS (int x, const S& r); 70 int a; 71 const S &b; 72 }; 73 SSS::SSS (int x, const S& r) : a(x), b(r) { } 74 75 class VirtualTest 76 { 77 private: 78 int value; 79 80 public: 81 VirtualTest () 82 { 83 value = 1; 84 } 85 }; 86 87 class Vbase1 : public virtual VirtualTest { }; 88 class Vbase2 : public virtual VirtualTest { }; 89 class Vbase3 : public virtual VirtualTest { }; 90 91 class Derived : public Vbase1, public Vbase2, public Vbase3 92 { 93 private: 94 int value; 95 96 public: 97 Derived () 98 { 99 value = 2; 100 } 101 }; 102 103 class Fake 104 { 105 int sname; 106 107 public: 108 Fake (const int name = 0): 109 sname (name) 110 { 111 } 112 }; 113 #endif 114 115 struct to_string_returns_value_inner 116 { 117 int val; 118 }; 119 120 struct to_string_returns_value_wrapper 121 { 122 struct to_string_returns_value_inner inner; 123 }; 124 125 struct substruct { 126 int a; 127 int b; 128 }; 129 130 struct outerstruct { 131 struct substruct s; 132 int x; 133 }; 134 135 struct outerstruct 136 substruct_test (void) 137 { 138 struct outerstruct outer; 139 outer.s.a = 0; 140 outer.s.b = 0; 141 outer.x = 0; 142 143 outer.s.a = 3; /* MI outer breakpoint here */ 144 145 return outer; 146 } 147 148 typedef struct string_repr 149 { 150 struct whybother 151 { 152 const char *contents; 153 } whybother; 154 } string; 155 156 /* This lets us avoid malloc. */ 157 int array[100]; 158 int narray[10]; 159 160 struct justchildren 161 { 162 int len; 163 int *elements; 164 }; 165 166 typedef struct justchildren nostring_type; 167 168 struct memory_error 169 { 170 const char *s; 171 }; 172 173 struct container 174 { 175 string name; 176 int len; 177 int *elements; 178 }; 179 180 typedef struct container zzz_type; 181 182 string 183 make_string (const char *s) 184 { 185 string result; 186 result.whybother.contents = s; 187 return result; 188 } 189 190 zzz_type 191 make_container (const char *s) 192 { 193 zzz_type result; 194 195 result.name = make_string (s); 196 result.len = 0; 197 result.elements = 0; 198 199 return result; 200 } 201 202 void 203 add_item (zzz_type *c, int val) 204 { 205 if (c->len == 0) 206 c->elements = array; 207 c->elements[c->len] = val; 208 ++c->len; 209 } 210 211 void 212 set_item(zzz_type *c, int i, int val) 213 { 214 if (i < c->len) 215 c->elements[i] = val; 216 } 217 218 void init_s(struct s *s, int a) 219 { 220 s->a = a; 221 s->b = &s->a; 222 } 223 224 void init_ss(struct ss *s, int a, int b) 225 { 226 init_s(&s->a, a); 227 init_s(&s->b, b); 228 } 229 230 void do_nothing(void) 231 { 232 int c; 233 234 c = 23; /* Another MI breakpoint */ 235 } 236 237 struct nullstr 238 { 239 char *s; 240 }; 241 242 struct string_repr string_1 = { { "one" } }; 243 struct string_repr string_2 = { { "two" } }; 244 245 int 246 eval_func (int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) 247 { 248 return p1; 249 } 250 251 static void 252 eval_sub (void) 253 { 254 struct eval_type_s { int x; } eval1 = { 1 }, eval2 = { 2 }, eval3 = { 3 }, 255 eval4 = { 4 }, eval5 = { 5 }, eval6 = { 6 }, 256 eval7 = { 7 }, eval8 = { 8 }, eval9 = { 9 }; 257 258 eval1.x++; /* eval-break */ 259 } 260 261 static void 262 bug_14741() 263 { 264 zzz_type c = make_container ("bug_14741"); 265 add_item (&c, 71); 266 set_item(&c, 0, 42); /* breakpoint bug 14741 */ 267 set_item(&c, 0, 5); 268 } 269 270 /* Some typedefs/variables for checking that GDB doesn't lose typedefs 271 when looking for a printer. */ 272 typedef int int_type; 273 typedef int_type int_type2; 274 typedef int_type int_type3; 275 276 int an_int = -1; 277 int_type an_int_type = 1; 278 int_type2 an_int_type2 = 2; 279 int_type3 an_int_type3 = 3; 280 281 int 282 main () 283 { 284 struct ss ss; 285 struct ss ssa[2]; 286 struct arraystruct arraystruct; 287 string x = make_string ("this is x"); 288 zzz_type c = make_container ("container"); 289 zzz_type c2 = make_container ("container2"); 290 const struct string_repr cstring = { { "const string" } }; 291 /* Clearing by being `static' could invoke an other GDB C++ bug. */ 292 struct nullstr nullstr; 293 nostring_type nstype, nstype2; 294 struct memory_error me; 295 struct ns ns, ns2; 296 struct lazystring estring, estring2, estring3; 297 struct hint_error hint_error; 298 struct children_as_list children_as_list; 299 struct to_string_returns_value_wrapper tsrvw = { { 1989 } }; 300 301 nstype.elements = narray; 302 nstype.len = 0; 303 304 me.s = "blah"; 305 306 init_ss(&ss, 1, 2); 307 init_ss(ssa+0, 3, 4); 308 init_ss(ssa+1, 5, 6); 309 memset (&nullstr, 0, sizeof nullstr); 310 311 arraystruct.y = 7; 312 init_s (&arraystruct.x[0], 23); 313 init_s (&arraystruct.x[1], 24); 314 315 ns.null_str = "embedded\0null\0string"; 316 ns.length = 20; 317 318 /* Make a "corrupted" string. */ 319 ns2.null_str = NULL; 320 ns2.length = 20; 321 322 estring.lazy_str = "embedded x\201\202\203\204"; 323 estring.len = -1; 324 325 /* Incomplete UTF-8, but ok Latin-1. */ 326 estring2.lazy_str = "embedded x\302"; 327 estring2.len = -1; 328 329 estring3.lazy_str = NULL; 330 estring3.len = 42; 331 332 #ifdef __cplusplus 333 S cps; 334 335 cps.zs = 7; 336 init_s(&cps, 8); 337 338 SS cpss; 339 cpss.zss = 9; 340 init_s(&cpss.s, 10); 341 342 SS cpssa[2]; 343 cpssa[0].zss = 11; 344 init_s(&cpssa[0].s, 12); 345 cpssa[1].zss = 13; 346 init_s(&cpssa[1].s, 14); 347 348 SSS sss(15, cps); 349 350 SSS& ref (sss); 351 352 Derived derived; 353 354 Fake fake (42); 355 #endif 356 357 add_item (&c, 23); /* MI breakpoint here */ 358 add_item (&c, 72); 359 360 #ifdef MI 361 add_item (&c, 1011); 362 c.elements[0] = 1023; 363 c.elements[0] = 2323; 364 365 add_item (&c2, 2222); 366 add_item (&c2, 3333); 367 368 substruct_test (); 369 do_nothing (); 370 #endif 371 372 nstype.elements[0] = 7; 373 nstype.elements[1] = 42; 374 nstype.len = 2; 375 376 nstype2 = nstype; 377 378 eval_sub (); 379 380 bug_14741(); /* break to inspect struct and union */ 381 return 0; 382 } 383