gdb/testsuite/gdb.base/infcall-nested-structs.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2018-2024 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 /* This file is used for testing GDBs ability to pass structures to, and
  19    return structures from, functions.  All of the structures in this test
  20    are special in that they are small structures containing from 1 up to 5
  21    scalar fields, the fields can be inside nested structures, and there can
  22    be empty structures around too.
  23
  24    When compiled for C++ this file also tests structures containing static
  25    members (which live in global memory).  In addition, empty structures in C++
  26    have a size of 1 (compared to 0 in GNU C), which can effect structure
  27    padding.
  28
  29    This test is specifically written for RiscV and Aarch64, which both have
  30    special ABI rules for structures like these, however, there should be no harm
  31    in running these tests on other targets, though in many cases the
  32    structures will treated no differently to the structures already covered
  33    in the structs.exp test script.  */
  34
  35 #include <string.h>
  36 #include "attributes.h"
  37
  38 /* Useful abreviations.  */
  39 typedef char tc;
  40 typedef short ts;
  41 typedef int ti;
  42 typedef long tl;
  43 typedef long long tll;
  44 typedef float tf;
  45 typedef double td;
  46 typedef long double tld;
  47
  48 #ifdef TEST_COMPLEX
  49 typedef float _Complex tfc;
  50 typedef double _Complex tdc;
  51 typedef long double _Complex tldc;
  52 #endif /* TEST_COMPLEX */
  53
  54 #define MAKE_CHECK_FUNCS(TYPE)                                  \
  55   int __attribute__((noinline)) ATTRIBUTE_NOCLONE               \
  56   check_arg_ ## TYPE (struct TYPE arg)                          \
  57   {                                                             \
  58     return cmp_ ## TYPE (arg, ref_val_ ## TYPE);                \
  59   }                                                             \
  60                                                                 \
  61   struct TYPE __attribute__((noinline)) ATTRIBUTE_NOCLONE       \
  62   rtn_str_ ## TYPE (void)                                       \
  63   {                                                             \
  64     return (ref_val_ ## TYPE);                                  \
  65   }
  66
  67 #define REF_VAL(NAME) struct NAME ref_val_ ## NAME
  68 #define ES(NAME) struct { } NAME
  69
  70 /* Test is either for a single type or two differing types.  */
  71 #if defined tA && ! defined tB
  72 #define tB tA
  73 #endif
  74 #if ! defined tB
  75 #error "Incorrect configuration of tA and tB defines"
  76 #endif
  77
  78 /* Structures with a single field nested to various depths, along with
  79    some empty structures.  */
  80 struct struct_01_01 { ES(es1); struct { struct { tA a; } s1; } s2; };
  81 struct struct_01_02 { tA a; struct { struct { ES(es1); } s1; } s2; };
  82 struct struct_01_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct { struct { tA a; } s3; } s4;};
  83 struct struct_01_04 { ES(es1); ES(es2); tA a; ES(es3); };
  84
  85 /* Structures with two fields nested to various depths, along with
  86    some empty structures.  */
  87 struct struct_02_01 { ES(es1); struct { struct { tA a; tB b; } s1; } s2; };
  88 struct struct_02_02 { tA a; struct { struct { ES(es1); } s1; } s2; tB b; };
  89 struct struct_02_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct { struct { tA a; } s3; } s4; struct { struct { tB b; } s5; } s6;};
  90 struct struct_02_04 { ES(es1); ES(es2); tA a; ES(es3); tB b; };
  91
  92 /* Structures with four fields nested to various depths, along with
  93    some empty structures.  */
  94 struct struct_04_01 { ES(es1); struct { struct { tA a; tB b; tA c; tB d; } s1; } s2; };
  95 struct struct_04_02 { tA a; struct { struct { ES(es1); } s1; } s2; tB b; struct { struct { ES(es1); } s2; } s3; tA c; struct { struct { ES(es2); } s4; } s5; tB d;};
  96 struct struct_04_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct { struct { tA a; } s3; } s4; struct { struct { tB b; } s5; } s6; struct { struct { tA c; } s7; } s8; struct { struct { tB d; } s9; } s10;};
  97 struct struct_04_04 { ES(es1); ES(es2); tA a; ES(es3); tB b; ES(es4); tA c; ES(es5); tB d; };
  98
  99 /* Structures with five fields nested to various depths, along with
 100    some empty structures.  */
 101 struct struct_05_01 { ES(es1); struct { struct { tA a; tB b; tA c; tB d; tA e; } s1; } s2; };
 102 struct struct_05_02 { tA a; struct { struct { ES(es1); } s1; } s2; tB b; struct { struct { ES(es1); } s2; } s3; tA c; struct { struct { ES(es2); } s4; } s5; tB d; struct { struct { ES(es2); } s6; } s7; tB e;};
 103 struct struct_05_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct { struct { tA a; } s3; } s4; struct { struct { tB b; } s5; } s6; struct { struct { tA c; } s7; } s8; struct { struct { tB d; } s9; } s10; struct { struct { tA e; } s11; } s12;};
 104 struct struct_05_04 { ES(es1); ES(es2); tA a; ES(es3); tB b; ES(es4); tA c; ES(es5); tB d; ES(es6); tA e; };
 105
 106 /* Only C++ allows structures to have static members.  */
 107 #ifdef __cplusplus
 108
 109 /* Structures with two fields nested to various depths, one of which is static.
 110    Some include empty structures.  */
 111 struct struct_static_02_01 { struct sa { struct sb { tA a; static tB b; } s1; } s2; };
 112 struct struct_static_02_02 { static tA a; struct { struct { ES(es1); } s1; } s2; tB b; };
 113 struct struct_static_02_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct { struct { tA a; } s3; } s4; struct sa { struct sb { static tB b; } s5; } s6;};
 114 struct struct_static_02_04 { static tA a; tB b; };
 115
 116 /* Structures with four fields nested to various depths, some of which are
 117    static.  Some include empty structures.  */
 118 struct struct_static_04_01 { struct sa { struct sb { static tA a; tB b; tA c; tB d; } s1; } s2; };
 119 struct struct_static_04_02 { tA a; struct { struct { ES(es1); } s1; } s2; tB b; struct { struct { ES(es1); } s2; } s3; static tA c; struct { struct { ES(es2); } s4; } s5; static tB d;};
 120 struct struct_static_04_03 { struct sa { struct sb { static tA a; } s3; } s4; struct sc { struct sd { static tB b; } s5; } s6; struct se { struct sf { static tA c; } s7; } s8; struct sg { struct sh { static tB d; } s9; } s10;};
 121 struct struct_static_04_04 { ES(es1); ES(es2); tA a; ES(es3); tB b; ES(es4); tA c; ES(es5); static tB d; };
 122
 123 /* Structures with six fields nested to various depths, some of which are
 124    static.  Some include empty structures.  */
 125 struct struct_static_06_01 { struct sa { struct sb { tA a; static tB b; tA c; tB d; tA e; } s1; } s2; tB f; };
 126 struct struct_static_06_02 { tA a; static tB b; static tA c; tB d; tB e; tA f;};
 127 struct struct_static_06_03 { struct { struct { ES(es1); } s1; } s2; ES(es1); struct sa { struct sb { static tA a; } s3; } s4; struct sc { struct sd { tB b; } s5; } s6; struct se { struct sf { static tA c; } s7; } s8; struct sg { struct sh { static tB d; } s9; } s10; struct { struct { tA e; tB f; } s11; } s12;};
 128 struct struct_static_06_04 { ES(es1); ES(es2); static tA a; ES(es3); static tB b; ES(es4); static tA c; ES(es5); static tB d; ES(es6); static tA e; ES(es7); tB f; };
 129
 130 #endif
 131
 132 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 133 cmp_struct_01_01 (struct struct_01_01 a, struct struct_01_01 b)
 134 { return a.s2.s1.a == b.s2.s1.a; }
 135
 136 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 137 cmp_struct_01_02 (struct struct_01_02 a, struct struct_01_02 b)
 138 { return a.a == b.a; }
 139
 140 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 141 cmp_struct_01_03 (struct struct_01_03 a, struct struct_01_03 b)
 142 { return a.s4.s3.a == b.s4.s3.a; }
 143
 144 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 145 cmp_struct_01_04 (struct struct_01_04 a, struct struct_01_04 b)
 146 { return a.a == b.a; }
 147
 148 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 149 cmp_struct_02_01 (struct struct_02_01 a, struct struct_02_01 b)
 150 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b; }
 151
 152 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 153 cmp_struct_02_02 (struct struct_02_02 a, struct struct_02_02 b)
 154 { return a.a == b.a && a.b == b.b; }
 155
 156 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 157 cmp_struct_02_03 (struct struct_02_03 a, struct struct_02_03 b)
 158 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b; }
 159
 160 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 161 cmp_struct_02_04 (struct struct_02_04 a, struct struct_02_04 b)
 162 { return a.a == b.a && a.b == b.b; }
 163
 164 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 165 cmp_struct_04_01 (struct struct_04_01 a, struct struct_04_01 b)
 166 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b
 167          && a.s2.s1.c == b.s2.s1.c && a.s2.s1.d == b.s2.s1.d; }
 168
 169 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 170 cmp_struct_04_02 (struct struct_04_02 a, struct struct_04_02 b)
 171 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d; }
 172
 173 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 174 cmp_struct_04_03 (struct struct_04_03 a, struct struct_04_03 b)
 175 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b
 176          && a.s8.s7.c == b.s8.s7.c && a.s10.s9.d == b.s10.s9.d; }
 177
 178 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 179 cmp_struct_04_04 (struct struct_04_04 a, struct struct_04_04 b)
 180 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d; }
 181
 182 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 183 cmp_struct_05_01 (struct struct_05_01 a, struct struct_05_01 b)
 184 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b
 185          && a.s2.s1.c == b.s2.s1.c && a.s2.s1.d == b.s2.s1.d
 186          && a.s2.s1.e == b.s2.s1.e; }
 187
 188 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 189 cmp_struct_05_02 (struct struct_05_02 a, struct struct_05_02 b)
 190 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d && a.e == b.e; }
 191
 192 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 193 cmp_struct_05_03 (struct struct_05_03 a, struct struct_05_03 b)
 194 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b
 195          && a.s8.s7.c == b.s8.s7.c && a.s10.s9.d == b.s10.s9.d
 196          && a.s12.s11.e == b.s12.s11.e; }
 197
 198 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 199 cmp_struct_05_04 (struct struct_05_04 a, struct struct_05_04 b)
 200 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d && a.e == b.e; }
 201
 202 #ifdef __cplusplus
 203
 204 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 205 cmp_struct_static_02_01 (struct struct_static_02_01 a,
 206                          struct struct_static_02_01 b)
 207 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b; }
 208
 209 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 210 cmp_struct_static_02_02 (struct struct_static_02_02 a,
 211                          struct struct_static_02_02 b)
 212 { return a.a == b.a && a.b == b.b; }
 213
 214 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 215 cmp_struct_static_02_03 (struct struct_static_02_03 a,
 216                          struct struct_static_02_03 b)
 217 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b; }
 218
 219 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 220 cmp_struct_static_02_04 (struct struct_static_02_04 a,
 221                              struct struct_static_02_04 b)
 222 { return a.a == b.a && a.b == b.b; }
 223
 224 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 225 cmp_struct_static_04_01 (struct struct_static_04_01 a,
 226                          struct struct_static_04_01 b)
 227 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b
 228          && a.s2.s1.c == b.s2.s1.c && a.s2.s1.d == b.s2.s1.d; }
 229
 230 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 231 cmp_struct_static_04_02 (struct struct_static_04_02 a,
 232                          struct struct_static_04_02 b)
 233 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d; }
 234
 235 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 236 cmp_struct_static_04_03 (struct struct_static_04_03 a,
 237                          struct struct_static_04_03 b)
 238 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b
 239          && a.s8.s7.c == b.s8.s7.c && a.s10.s9.d == b.s10.s9.d; }
 240
 241 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 242 cmp_struct_static_04_04 (struct struct_static_04_04 a,
 243                          struct struct_static_04_04 b)
 244 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d; }
 245
 246 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 247 cmp_struct_static_06_01 (struct struct_static_06_01 a,
 248                          struct struct_static_06_01 b)
 249 { return a.s2.s1.a == b.s2.s1.a && a.s2.s1.b == b.s2.s1.b
 250          && a.s2.s1.c == b.s2.s1.c && a.s2.s1.d == b.s2.s1.d
 251          && a.s2.s1.e == b.s2.s1.e && a.f == b.f; }
 252
 253 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 254 cmp_struct_static_06_02 (struct struct_static_06_02 a,
 255                          struct struct_static_06_02 b)
 256 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d && a.e == b.e
 257          && a.f == b.f; }
 258
 259 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 260 cmp_struct_static_06_03 (struct struct_static_06_03 a,
 261                          struct struct_static_06_03 b)
 262 { return a.s4.s3.a == b.s4.s3.a && a.s6.s5.b == b.s6.s5.b
 263          && a.s8.s7.c == b.s8.s7.c && a.s10.s9.d == b.s10.s9.d
 264          && a.s12.s11.e == b.s12.s11.e && a.s12.s11.f == b.s12.s11.f; }
 265
 266 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 267 cmp_struct_static_06_04 (struct struct_static_06_04 a,
 268                          struct struct_static_06_04 b)
 269 { return a.a == b.a && a.b == b.b && a.c == b.c && a.d == b.d && a.e == b.e
 270          && a.f == b.f; }
 271
 272 #endif
 273
 274 REF_VAL(struct_01_01) = { {}, { { 'a' } } };
 275 REF_VAL(struct_01_02) = { 'a', { { {} } } };
 276 REF_VAL(struct_01_03) = { { { {} } }, {}, { { 'a' } } };
 277 REF_VAL(struct_01_04) = { {}, {}, 'a', {} };
 278
 279 REF_VAL(struct_02_01) = { {}, { { 'a', 'b' } } };
 280 REF_VAL(struct_02_02) = { 'a', { { {} } }, 'b' };
 281 REF_VAL(struct_02_03) = { { { {} } }, {}, { { 'a' } }, { { 'b' } } };
 282 REF_VAL(struct_02_04) = { {}, {}, 'a', {}, 'b' };
 283
 284 REF_VAL(struct_04_01) = { {}, { { 'a', 'b', 'c', 'd' } } };
 285 REF_VAL(struct_04_02) = { 'a', { { {} } }, 'b', { { {} } }, 'c', { { {} } }, 'd' };
 286 REF_VAL(struct_04_03) = { { { {} } }, {}, { { 'a' } }, { { 'b' } }, { { 'c' } }, { { 'd' } } };
 287 REF_VAL(struct_04_04) = { {}, {}, 'a', {}, 'b', {}, 'c', {}, 'd' };
 288
 289 REF_VAL(struct_05_01) = { {}, { { 'a', 'b', 'c', 'd', 'e' } } };
 290 REF_VAL(struct_05_02) = { 'a', { { {} } }, 'b', { { {} } }, 'c', { { {} } }, 'd', { { {} } }, 'e' };
 291 REF_VAL(struct_05_03) = { { { {} } }, {}, { { 'a' } }, { { 'b' } }, { { 'c' } }, { { 'd' } }, { { 'e' } } };
 292 REF_VAL(struct_05_04) = { {}, {}, 'a', {}, 'b', {}, 'c', {}, 'd', {}, 'e' };
 293
 294 #ifdef __cplusplus
 295
 296 /* Initialise static members.  */
 297 tB struct_static_02_01::sa::sb::b = '1';
 298 tA struct_static_02_02::a = '2';
 299 tB struct_static_02_03::sa::sb::b = '3';
 300 tA struct_static_02_04::a = '4';
 301 tA struct_static_04_01::sa::sb::a = '5';
 302 tA struct_static_04_02::c = '6';
 303 tB struct_static_04_02::d = '7';
 304 tA struct_static_04_03::sa::sb::a = '8';
 305 tB struct_static_04_03::sc::sd::b = '9';
 306 tA struct_static_04_03::se::sf::c = '0';
 307 tB struct_static_04_03::sg::sh::d = 'A';
 308 tB struct_static_04_04::d = 'B';
 309 tB struct_static_06_01::sa::sb::b = 'C';
 310 tB struct_static_06_02::b = 'D';
 311 tA struct_static_06_02::c = 'E';
 312 tA struct_static_06_03::sa::sb::a = 'F';
 313 tA struct_static_06_03::se::sf::c = 'G';
 314 tB struct_static_06_03::sg::sh::d = 'H';
 315 tA struct_static_06_04::a = 'I';
 316 tB struct_static_06_04::b = 'J';
 317 tA struct_static_06_04::c = 'K';
 318 tB struct_static_06_04::d = 'L';
 319 tA struct_static_06_04::e = 'M';
 320
 321 REF_VAL(struct_static_02_01) = { { { 'a' } } };
 322 REF_VAL(struct_static_02_02) = { { { {} } }, 'b' };
 323 REF_VAL(struct_static_02_03) = { { { {} } }, {}, { { 'a' } }, { { } } };
 324 REF_VAL(struct_static_02_04) = { 'b' };
 325 REF_VAL(struct_static_04_01) = { { { 'b', 'c', 'd' } } };
 326 REF_VAL(struct_static_04_02) = { 'a', { { {} } }, 'b', { { {} } }, { { {} } } };
 327 REF_VAL(struct_static_04_03) = {};
 328 REF_VAL(struct_static_04_04) = { {}, {}, 'a', {}, 'b', {}, 'c', {} };
 329 REF_VAL(struct_static_06_01) = { { { 'a', 'c', 'd', 'e' } }, 'f' };
 330 REF_VAL(struct_static_06_02) = { 'a', 'd', 'e', 'f' };
 331 REF_VAL(struct_static_06_03) = { { { {} } }, {}, {}, { { 'b' } }, {}, /*{ { 'e', 'f' } }*/ };
 332 REF_VAL(struct_static_06_04) = { {}, {}, {}, {}, {}, {}, {}, 'f' };
 333
 334 #endif
 335
 336 /* Create all of the functions GDB will call to check functionality.  */
 337 MAKE_CHECK_FUNCS(struct_01_01)
 338 MAKE_CHECK_FUNCS(struct_01_02)
 339 MAKE_CHECK_FUNCS(struct_01_03)
 340 MAKE_CHECK_FUNCS(struct_01_04)
 341 MAKE_CHECK_FUNCS(struct_02_01)
 342 MAKE_CHECK_FUNCS(struct_02_02)
 343 MAKE_CHECK_FUNCS(struct_02_03)
 344 MAKE_CHECK_FUNCS(struct_02_04)
 345 MAKE_CHECK_FUNCS(struct_04_01)
 346 MAKE_CHECK_FUNCS(struct_04_02)
 347 MAKE_CHECK_FUNCS(struct_04_03)
 348 MAKE_CHECK_FUNCS(struct_04_04)
 349 MAKE_CHECK_FUNCS(struct_05_01)
 350 MAKE_CHECK_FUNCS(struct_05_02)
 351 MAKE_CHECK_FUNCS(struct_05_03)
 352 MAKE_CHECK_FUNCS(struct_05_04)
 353 #ifdef __cplusplus
 354 MAKE_CHECK_FUNCS(struct_static_02_01)
 355 MAKE_CHECK_FUNCS(struct_static_02_02)
 356 MAKE_CHECK_FUNCS(struct_static_02_03)
 357 MAKE_CHECK_FUNCS(struct_static_02_04)
 358 MAKE_CHECK_FUNCS(struct_static_04_01)
 359 MAKE_CHECK_FUNCS(struct_static_04_02)
 360 MAKE_CHECK_FUNCS(struct_static_04_03)
 361 MAKE_CHECK_FUNCS(struct_static_04_04)
 362 MAKE_CHECK_FUNCS(struct_static_06_01)
 363 MAKE_CHECK_FUNCS(struct_static_06_02)
 364 MAKE_CHECK_FUNCS(struct_static_06_03)
 365 MAKE_CHECK_FUNCS(struct_static_06_04)
 366 #endif
 367
 368 #define CALL_LINE(NAME) val += check_arg_ ## NAME (rtn_str_ ## NAME ())
 369
 370 int __attribute__((noinline)) ATTRIBUTE_NOCLONE
 371 call_all ()
 372 {
 373   int val = 0;
 374
 375   CALL_LINE(struct_01_01);
 376   CALL_LINE(struct_01_02);
 377   CALL_LINE(struct_01_03);
 378   CALL_LINE(struct_01_04);
 379   CALL_LINE(struct_02_01);
 380   CALL_LINE(struct_02_02);
 381   CALL_LINE(struct_02_03);
 382   CALL_LINE(struct_02_04);
 383   CALL_LINE(struct_04_01);
 384   CALL_LINE(struct_04_02);
 385   CALL_LINE(struct_04_03);
 386   CALL_LINE(struct_04_04);
 387   CALL_LINE(struct_05_01);
 388   CALL_LINE(struct_05_02);
 389   CALL_LINE(struct_05_03);
 390   CALL_LINE(struct_05_04);
 391 #ifdef __cplusplus
 392   CALL_LINE(struct_static_02_01);
 393   CALL_LINE(struct_static_02_02);
 394   CALL_LINE(struct_static_02_03);
 395   CALL_LINE(struct_static_02_04);
 396   CALL_LINE(struct_static_04_01);
 397   CALL_LINE(struct_static_04_02);
 398   CALL_LINE(struct_static_04_03);
 399   CALL_LINE(struct_static_04_04);
 400   CALL_LINE(struct_static_06_01);
 401   CALL_LINE(struct_static_06_02);
 402   CALL_LINE(struct_static_06_03);
 403   CALL_LINE(struct_static_06_04);
 404 #endif
 405
 406   return val;
 407 }
 408
 409 int volatile v = 1;
 410
 411 void __attribute__((noinline)) ATTRIBUTE_NOCLONE
 412 breakpt (void)
 413 {
 414   v++;
 415 }
 416
 417 int
 418 main ()
 419 {
 420   int res;
 421
 422   res = call_all ();
 423   breakpt (); /* Break Here.  */
 424   return res;
 425 }