gdb/testsuite/gdb.mi/mi-var-child.c

   1 /* Copyright 1999-2019 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   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 <stdlib.h>
  19 #include <string.h>
  20
  21 struct _simple_struct {
  22   int integer;
  23   unsigned int unsigned_integer;
  24   char character;
  25   signed char signed_character;
  26   char *char_ptr;
  27   int array_of_10[10];
  28 };
  29
  30 typedef struct _simple_struct simpleton;
  31
  32 simpleton global_simple;
  33
  34 enum foo {
  35   bar = 1,
  36   baz
  37 };
  38
  39 typedef enum foo efoo;
  40
  41 union named_union
  42 {
  43   int integer;
  44   char *char_ptr;
  45 };
  46
  47 typedef struct _struct_decl {
  48   int   integer;
  49   char  character;
  50   char *char_ptr;
  51   long  long_int;
  52   int  **int_ptr_ptr;
  53   long  long_array[12];
  54
  55   void (*func_ptr) (void);
  56   struct _struct_decl (*func_ptr_struct) (int, char *, long);
  57   struct _struct_decl *(*func_ptr_ptr) (int, char *, long);
  58   union {
  59     int   a;
  60     char *b;
  61     long  c;
  62     enum foo d;
  63   } u1;
  64
  65   struct {
  66     union {
  67       struct {
  68         int d;
  69         char e[10];
  70         int *(*func) (void);
  71         efoo foo;
  72       } u1s1;
  73
  74       long f;
  75       struct {
  76         char array_ptr[2];
  77         int (*func) (int, char *);
  78       } u1s2;
  79     } u2;
  80
  81     int g;
  82     char h;
  83     long i[10];
  84   } s2;
  85 } weird_struct;
  86
  87 struct _struct_n_pointer {
  88   char ****char_ptr;
  89   long ****long_ptr;
  90   struct _struct_n_pointer *ptrs[3];
  91   struct _struct_n_pointer *next;
  92 };
  93
  94 void do_locals_tests (void);
  95 void do_block_tests (void);
  96 void subroutine1 (int, long *);
  97 void nothing (void);
  98 void do_children_tests (void);
  99 void do_special_tests (void);
 100 void incr_a (char);
 101
 102 void incr_a (char a)
 103 {
 104   int b;
 105   b = a;
 106 }
 107
 108 void
 109 do_locals_tests ()
 110 {
 111   int linteger;
 112   int *lpinteger;
 113   char lcharacter;
 114   char *lpcharacter;
 115   long llong;
 116   long *lplong;
 117   float lfloat;
 118   float *lpfloat;
 119   double ldouble;
 120   double *lpdouble;
 121   struct _simple_struct lsimple;
 122   struct _simple_struct *lpsimple;
 123   void (*func) (void);
 124
 125   /* Simple assignments */
 126   linteger = 1234;
 127   lpinteger = &linteger;
 128   lcharacter = 'a';
 129   lpcharacter = &lcharacter;
 130   llong = 2121L;
 131   lplong = &llong;
 132   lfloat = 2.1;
 133   lpfloat = &lfloat;
 134   ldouble = 2.718281828459045;
 135   lpdouble = &ldouble;
 136   lsimple.integer = 1234;
 137   lsimple.unsigned_integer = 255;
 138   lsimple.character = 'a';
 139   lsimple.signed_character = 21;
 140   lsimple.char_ptr = &lcharacter;
 141   lpsimple = &lsimple;
 142   func = nothing;
 143
 144   /* Check pointers */
 145   linteger = 4321;
 146   lcharacter = 'b';
 147   llong = 1212L;
 148   lfloat = 1.2;
 149   ldouble = 5.498548281828172;
 150   lsimple.integer = 255;
 151   lsimple.unsigned_integer = 4321;
 152   lsimple.character = 'b';
 153   lsimple.signed_character = 0;
 154
 155   subroutine1 (linteger, &llong);
 156 }
 157
 158 void
 159 nothing ()
 160 {
 161 }
 162
 163 struct _struct_decl
 164 nothing1 (int a, char *b, long c)
 165 {
 166   struct _struct_decl foo;
 167
 168   return foo;
 169 }
 170
 171 struct _struct_decl *
 172 nothing2 (int a, char *b, long c)
 173 {
 174   return (struct _struct_decl *) 0;
 175 }
 176
 177 void
 178 subroutine1 (int i, long *l)
 179 {
 180   global_simple.integer = i + 3;
 181   i = 212;
 182   *l = 12;
 183 }
 184
 185 void
 186 do_block_tests ()
 187 {
 188   int cb = 12;
 189
 190   {
 191     int foo;
 192     foo = 123;
 193     {
 194       int foo2;
 195       foo2 = 123;
 196       {
 197         int foo;
 198         foo = 321;
 199       }
 200       foo2 = 0;
 201     }
 202     foo = 0;
 203   }
 204
 205   cb = 21;
 206 }
 207
 208 void
 209 do_children_tests (void)
 210 {
 211   weird_struct *weird;
 212   struct _struct_n_pointer *psnp;
 213   struct _struct_n_pointer snp0, snp1, snp2;
 214   char a0[2] = {}, *a1, **a2, ***a3;
 215   char b0[2] = {}, *b1, **b2, ***b3;
 216   char c0[2] = {}, *c1, **c2, ***c3;
 217   long z0, *z1, **z2, ***z3;
 218   long y0, *y1, **y2, ***y3;
 219   long x0, *x1, **x2, ***x3;
 220   int *foo;
 221   int bar;
 222
 223   /* Avoid pointing into NULL, as that is editable on some
 224      systems.  */
 225   int dummy;
 226   int *dummy_ptr = &dummy;
 227
 228   struct _struct_decl struct_declarations = { 0, 0, NULL, 0, &dummy_ptr };
 229   weird = &struct_declarations;
 230
 231   struct_declarations.integer = 123;
 232   weird->char_ptr = "hello";
 233   bar = 2121;
 234   foo = &bar;
 235   struct_declarations.int_ptr_ptr = &foo;
 236   weird->long_array[0] = 1234;
 237   struct_declarations.long_array[1] = 2345;
 238   weird->long_array[2] = 3456;
 239   struct_declarations.long_array[3] = 4567;
 240   weird->long_array[4] = 5678;
 241   struct_declarations.long_array[5] = 6789;
 242   weird->long_array[6] = 7890;
 243   struct_declarations.long_array[7] = 8901;
 244   weird->long_array[8] = 9012;
 245   struct_declarations.long_array[9] = 1234;
 246
 247   weird->func_ptr = nothing;
 248   weird->func_ptr_struct = nothing1;
 249   weird->func_ptr_ptr = nothing2;
 250   struct_declarations.long_array[10] = 3456;
 251   struct_declarations.long_array[11] = 5678;
 252
 253   /* Struct/pointer/array tests */
 254   a0[0] = '0';
 255   a1 = a0;
 256   a2 = &a1;
 257   a3 = &a2;
 258   b0[0] = '1';
 259   b1 = b0;
 260   b2 = &b1;
 261   b3 = &b2;
 262   c0[1] = '2';
 263   c1 = c0;
 264   c2 = &c1;
 265   c3 = &c2;
 266   z0 = 0xdead + 0;
 267   z1 = &z0;
 268   z2 = &z1;
 269   z3 = &z2;
 270   y0 = 0xdead + 1;
 271   y1 = &y0;
 272   y2 = &y1;
 273   y3 = &y2;
 274   x0 = 0xdead + 2;
 275   x1 = &x0;
 276   x2 = &x1;
 277   x3 = &x2;
 278   snp0.char_ptr = &a3;
 279   snp0.long_ptr = &z3;
 280   snp0.ptrs[0] = &snp0;
 281   snp0.ptrs[1] = &snp1;
 282   snp0.ptrs[2] = &snp2;
 283   snp0.next = &snp1;
 284   snp1.char_ptr = &b3;
 285   snp1.long_ptr = &y3;
 286   snp1.ptrs[0] = &snp0;
 287   snp1.ptrs[1] = &snp1;
 288   snp1.ptrs[2] = &snp2;
 289   snp1.next = &snp2;
 290   snp2.char_ptr = &c3;
 291   snp2.long_ptr = &x3;
 292   snp2.ptrs[0] = &snp0;
 293   snp2.ptrs[1] = &snp1;
 294   snp2.ptrs[2] = &snp2;
 295   snp2.next = 0x0;
 296   psnp = &snp0;
 297   snp0.char_ptr = &b3;
 298   snp1.char_ptr = &c3;
 299   snp2.char_ptr = &a3;
 300   snp0.long_ptr = &y3;
 301   snp1.long_ptr = &x3;
 302   snp2.long_ptr = &z3;
 303 }
 304
 305 void
 306 do_special_tests (void)
 307 {
 308   union named_union u;
 309   union {
 310     int a;
 311     char b;
 312     long c;
 313   } anonu;
 314   struct _simple_struct s;
 315   struct {
 316     int a;
 317     char b;
 318     long c;
 319   } anons;
 320   enum foo e;
 321   enum { A, B, C } anone;
 322   int array[21];
 323   int a;
 324
 325   a = 1;
 326   incr_a(2);
 327 }
 328
 329 struct very_simple_struct
 330 {
 331   int a;
 332   int b;
 333 };
 334
 335 int
 336 do_child_deletion (void)
 337 {
 338   /*: BEGIN: child_deletion :*/
 339   struct very_simple_struct s = {1, 2};
 340   /*:
 341     mi_create_varobj S s "create varobj for s"
 342     mi_list_varobj_children S {{S.a a 0 int} {S.b b 0 int}}     \
 343        "list children of S"
 344     mi_delete_varobj S.a "delete S.a"
 345     mi_delete_varobj S.b "delete S.b"
 346     mi_delete_varobj S "delete S"
 347     :*/
 348   return 99;
 349   /*: END: child_deletion :*/
 350 }
 351
 352 int
 353 main (int argc, char *argv [])
 354 {
 355   do_locals_tests ();
 356   do_block_tests ();
 357   do_children_tests ();
 358   do_special_tests ();
 359   do_child_deletion ();
 360   exit (0);
 361 }
 362
 363