• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>&1 \
2 // RUN:            | FileCheck %s
3 // RUN: %clang_cc1 -fno-rtti -fms-extensions -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
4 // RUN:            | FileCheck %s -check-prefix CHECK-X64
5 
6 extern "C" int printf(const char *fmt, ...);
7 
8 struct B0 {
9 	int a;
B0B010 	B0() : a(0xf00000B0) {}
fB011 	virtual void f() { printf("B0"); }
12 };
13 
14 struct __declspec(align(16)) B1 {
15 	int a;
B1B116 	B1() : a(0xf00000B1) {}
fB117 	virtual void f() { printf("B1"); }
18 };
19 
20 struct __declspec(align(16)) Align16 {};
21 struct __declspec(align(32)) Align32 {};
22 struct VAlign16 : virtual Align16 {};
23 struct VAlign32 : virtual Align32 {};
24 
25 struct A : virtual B0, virtual B1 {
26 	int a;
AA27 	A() : a(0xf000000A) {}
fA28 	virtual void f() { printf("A"); }
gA29 	virtual void g() { printf("A"); }
30 };
31 
32 // CHECK: *** Dumping AST Record Layout
33 // CHECK: *** Dumping AST Record Layout
34 // CHECK: *** Dumping AST Record Layout
35 // CHECK-NEXT:    0 | struct A
36 // CHECK-NEXT:    0 |   (A vftable pointer)
37 // CHECK-NEXT:    4 |   (A vbtable pointer)
38 // CHECK-NEXT:    8 |   int a
39 // CHECK-NEXT:   16 |   (vtordisp for vbase B0)
40 // CHECK-NEXT:   20 |   struct B0 (virtual base)
41 // CHECK-NEXT:   20 |     (B0 vftable pointer)
42 // CHECK-NEXT:   24 |     int a
43 // CHECK-NEXT:   44 |   (vtordisp for vbase B1)
44 // CHECK-NEXT:   48 |   struct B1 (virtual base)
45 // CHECK-NEXT:   48 |     (B1 vftable pointer)
46 // CHECK-NEXT:   52 |     int a
47 // CHECK-NEXT:      | [sizeof=64, align=16
48 // CHECK-NEXT:      |  nvsize=12, nvalign=16]
49 // CHECK-X64: *** Dumping AST Record Layout
50 // CHECK-X64: *** Dumping AST Record Layout
51 // CHECK-X64: *** Dumping AST Record Layout
52 // CHECK-X64-NEXT:    0 | struct A
53 // CHECK-X64-NEXT:    0 |   (A vftable pointer)
54 // CHECK-X64-NEXT:    8 |   (A vbtable pointer)
55 // CHECK-X64-NEXT:   16 |   int a
56 // CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
57 // CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
58 // CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
59 // CHECK-X64-NEXT:   48 |     int a
60 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
61 // CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
62 // CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
63 // CHECK-X64-NEXT:   88 |     int a
64 // CHECK-X64-NEXT:      | [sizeof=96, align=16
65 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
66 
67 struct C : virtual B0, virtual B1, VAlign32 {
68 	int a;
CC69 	C() : a(0xf000000C) {}
fC70 	virtual void f() { printf("C"); }
gC71 	virtual void g() { printf("C"); }
72 };
73 
74 // CHECK: *** Dumping AST Record Layout
75 // CHECK: *** Dumping AST Record Layout
76 // CHECK: *** Dumping AST Record Layout
77 // CHECK-NEXT:    0 | struct C
78 // CHECK-NEXT:    0 |   (C vftable pointer)
79 // CHECK-NEXT:   32 |   struct VAlign32 (base)
80 // CHECK-NEXT:   32 |     (VAlign32 vbtable pointer)
81 // CHECK-NEXT:   36 |   int a
82 // CHECK-NEXT:   64 |   (vtordisp for vbase B0)
83 // CHECK-NEXT:   68 |   struct B0 (virtual base)
84 // CHECK-NEXT:   68 |     (B0 vftable pointer)
85 // CHECK-NEXT:   72 |     int a
86 // CHECK-NEXT:  108 |   (vtordisp for vbase B1)
87 // CHECK-NEXT:  112 |   struct B1 (virtual base)
88 // CHECK-NEXT:  112 |     (B1 vftable pointer)
89 // CHECK-NEXT:  116 |     int a
90 // CHECK-NEXT:  128 |   struct Align32 (virtual base) (empty)
91 // CHECK-NEXT:      | [sizeof=128, align=32
92 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
93 // CHECK-X64: *** Dumping AST Record Layout
94 // CHECK-X64: *** Dumping AST Record Layout
95 // CHECK-X64: *** Dumping AST Record Layout
96 // CHECK-X64-NEXT:    0 | struct C
97 // CHECK-X64-NEXT:    0 |   (C vftable pointer)
98 // CHECK-X64-NEXT:   32 |   struct VAlign32 (base)
99 // CHECK-X64-NEXT:   32 |     (VAlign32 vbtable pointer)
100 // CHECK-X64-NEXT:   40 |   int a
101 // CHECK-X64-NEXT:   68 |   (vtordisp for vbase B0)
102 // CHECK-X64-NEXT:   72 |   struct B0 (virtual base)
103 // CHECK-X64-NEXT:   72 |     (B0 vftable pointer)
104 // CHECK-X64-NEXT:   80 |     int a
105 // CHECK-X64-NEXT:  108 |   (vtordisp for vbase B1)
106 // CHECK-X64-NEXT:  112 |   struct B1 (virtual base)
107 // CHECK-X64-NEXT:  112 |     (B1 vftable pointer)
108 // CHECK-X64-NEXT:  120 |     int a
109 // CHECK-X64-NEXT:  128 |   struct Align32 (virtual base) (empty)
110 // CHECK-X64-NEXT:      | [sizeof=128, align=32
111 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
112 
113 struct __declspec(align(32)) D : virtual B0, virtual B1  {
114 	int a;
DD115 	D() : a(0xf000000D) {}
fD116 	virtual void f() { printf("D"); }
gD117 	virtual void g() { printf("D"); }
118 };
119 
120 // CHECK: *** Dumping AST Record Layout
121 // CHECK-NEXT:    0 | struct D
122 // CHECK-NEXT:    0 |   (D vftable pointer)
123 // CHECK-NEXT:    4 |   (D vbtable pointer)
124 // CHECK-NEXT:    8 |   int a
125 // CHECK-NEXT:   32 |   (vtordisp for vbase B0)
126 // CHECK-NEXT:   36 |   struct B0 (virtual base)
127 // CHECK-NEXT:   36 |     (B0 vftable pointer)
128 // CHECK-NEXT:   40 |     int a
129 // CHECK-NEXT:   76 |   (vtordisp for vbase B1)
130 // CHECK-NEXT:   80 |   struct B1 (virtual base)
131 // CHECK-NEXT:   80 |     (B1 vftable pointer)
132 // CHECK-NEXT:   84 |     int a
133 // CHECK-NEXT:      | [sizeof=96, align=32
134 // CHECK-NEXT:      |  nvsize=12, nvalign=32]
135 // CHECK-X64: *** Dumping AST Record Layout
136 // CHECK-X64-NEXT:    0 | struct D
137 // CHECK-X64-NEXT:    0 |   (D vftable pointer)
138 // CHECK-X64-NEXT:    8 |   (D vbtable pointer)
139 // CHECK-X64-NEXT:   16 |   int a
140 // CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
141 // CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
142 // CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
143 // CHECK-X64-NEXT:   48 |     int a
144 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
145 // CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
146 // CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
147 // CHECK-X64-NEXT:   88 |     int a
148 // CHECK-X64-NEXT:      | [sizeof=96, align=32
149 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=32]
150 
151 struct AT {
~ATAT152 	virtual ~AT(){}
153 };
154 struct CT : virtual AT {
155 	virtual ~CT();
156 };
~CT()157 CT::~CT(){}
158 
159 // CHECK: *** Dumping AST Record Layout
160 // CHECK: *** Dumping AST Record Layout
161 // CHECK-NEXT:    0 | struct CT
162 // CHECK-NEXT:    0 |   (CT vbtable pointer)
163 // CHECK-NEXT:    4 |   struct AT (virtual base)
164 // CHECK-NEXT:    4 |     (AT vftable pointer)
165 // CHECK-NEXT:      | [sizeof=8, align=4
166 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
167 // CHECK-X64: *** Dumping AST Record Layout
168 // CHECK-X64: *** Dumping AST Record Layout
169 // CHECK-X64-NEXT:    0 | struct CT
170 // CHECK-X64-NEXT:    0 |   (CT vbtable pointer)
171 // CHECK-X64-NEXT:    8 |   struct AT (virtual base)
172 // CHECK-X64-NEXT:    8 |     (AT vftable pointer)
173 // CHECK-X64-NEXT:      | [sizeof=16, align=8
174 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
175 
176 struct XA {
XAXA177 	XA() { printf("XA"); }
178 	long long ll;
179 };
180 struct XB : XA {
XBXB181 	XB() { printf("XB"); }
fooXB182 	virtual void foo() {}
183 	int b;
184 };
185 struct XC : virtual XB {
XCXC186 	XC() { printf("XC"); }
fooXC187 	virtual void foo() {}
188 };
189 
190 // CHECK: *** Dumping AST Record Layout
191 // CHECK: *** Dumping AST Record Layout
192 // CHECK: *** Dumping AST Record Layout
193 // CHECK-NEXT:    0 | struct XC
194 // CHECK-NEXT:    0 |   (XC vbtable pointer)
195 // CHECK-NEXT:    4 |   (vtordisp for vbase XB)
196 // CHECK-NEXT:    8 |   struct XB (virtual base)
197 // CHECK-NEXT:    8 |     (XB vftable pointer)
198 // CHECK-NEXT:   16 |     struct XA (base)
199 // CHECK-NEXT:   16 |       long long ll
200 // CHECK-NEXT:   24 |     int b
201 // CHECK-NEXT:      | [sizeof=32, align=8
202 // CHECK-NEXT:      |  nvsize=4, nvalign=8]
203 // CHECK-X64: *** Dumping AST Record Layout
204 // CHECK-X64: *** Dumping AST Record Layout
205 // CHECK-X64: *** Dumping AST Record Layout
206 // CHECK-X64-NEXT:    0 | struct XC
207 // CHECK-X64-NEXT:    0 |   (XC vbtable pointer)
208 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase XB)
209 // CHECK-X64-NEXT:   16 |   struct XB (virtual base)
210 // CHECK-X64-NEXT:   16 |     (XB vftable pointer)
211 // CHECK-X64-NEXT:   24 |     struct XA (base)
212 // CHECK-X64-NEXT:   24 |       long long ll
213 // CHECK-X64-NEXT:   32 |     int b
214 // CHECK-X64-NEXT:      | [sizeof=40, align=8
215 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
216 
217 namespace pragma_test1 {
218 // No overrides means no vtordisps by default.
219 struct A { virtual ~A(); virtual void foo(); int a; };
220 struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
221 struct C : virtual B { int c; };
222 // CHECK: *** Dumping AST Record Layout
223 // CHECK: *** Dumping AST Record Layout
224 // CHECK: *** Dumping AST Record Layout
225 // CHECK-NEXT:    0 | struct pragma_test1::C
226 // CHECK-NEXT:    0 |   (C vbtable pointer)
227 // CHECK-NEXT:    4 |   int c
228 // CHECK-NEXT:    8 |   struct pragma_test1::A (virtual base)
229 // CHECK-NEXT:    8 |     (A vftable pointer)
230 // CHECK-NEXT:   12 |     int a
231 // CHECK-NEXT:   16 |   struct pragma_test1::B (virtual base)
232 // CHECK-NEXT:   16 |     (B vftable pointer)
233 // CHECK-NEXT:   20 |     (B vbtable pointer)
234 // CHECK-NEXT:   24 |     int b
235 // CHECK-NEXT:      | [sizeof=28, align=4
236 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
237 // CHECK-X64: *** Dumping AST Record Layout
238 // CHECK-X64: *** Dumping AST Record Layout
239 // CHECK-X64: *** Dumping AST Record Layout
240 }
241 
242 namespace pragma_test2 {
243 struct A { virtual ~A(); virtual void foo(); int a; };
244 #pragma vtordisp(push,2)
245 struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
246 struct C : virtual B { int c; };
247 #pragma vtordisp(pop)
248 // CHECK: *** Dumping AST Record Layout
249 // CHECK: *** Dumping AST Record Layout
250 // CHECK: *** Dumping AST Record Layout
251 // CHECK-NEXT:    0 | struct pragma_test2::C
252 // CHECK-NEXT:    0 |   (C vbtable pointer)
253 // CHECK-NEXT:    4 |   int c
254 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
255 // CHECK-NEXT:   12 |   struct pragma_test2::A (virtual base)
256 // CHECK-NEXT:   12 |     (A vftable pointer)
257 // CHECK-NEXT:   16 |     int a
258 //   By adding a virtual method and vftable to B, now we need a vtordisp.
259 // CHECK-NEXT:   20 |   (vtordisp for vbase B)
260 // CHECK-NEXT:   24 |   struct pragma_test2::B (virtual base)
261 // CHECK-NEXT:   24 |     (B vftable pointer)
262 // CHECK-NEXT:   28 |     (B vbtable pointer)
263 // CHECK-NEXT:   32 |     int b
264 // CHECK-NEXT:      | [sizeof=36, align=4
265 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
266 // CHECK-X64: *** Dumping AST Record Layout
267 // CHECK-X64: *** Dumping AST Record Layout
268 // CHECK-X64: *** Dumping AST Record Layout
269 }
270 
271 namespace pragma_test3 {
272 struct A { virtual ~A(); virtual void foo(); int a; };
273 #pragma vtordisp(push,2)
274 struct B : virtual A { virtual ~B(); virtual void foo(); int b; };
275 struct C : virtual B { int c; };
276 #pragma vtordisp(pop)
277 // CHECK: *** Dumping AST Record Layout
278 // CHECK: *** Dumping AST Record Layout
279 // CHECK: *** Dumping AST Record Layout
280 // CHECK-NEXT:    0 | struct pragma_test3::C
281 // CHECK-NEXT:    0 |   (C vbtable pointer)
282 // CHECK-NEXT:    4 |   int c
283 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
284 // CHECK-NEXT:   12 |   struct pragma_test3::A (virtual base)
285 // CHECK-NEXT:   12 |     (A vftable pointer)
286 // CHECK-NEXT:   16 |     int a
287 //   No vtordisp before B!  It doesn't have its own vftable.
288 // CHECK-NEXT:   20 |   struct pragma_test3::B (virtual base)
289 // CHECK-NEXT:   20 |     (B vbtable pointer)
290 // CHECK-NEXT:   24 |     int b
291 // CHECK-NEXT:      | [sizeof=28, align=4
292 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
293 // CHECK-X64: *** Dumping AST Record Layout
294 // CHECK-X64: *** Dumping AST Record Layout
295 // CHECK-X64: *** Dumping AST Record Layout
296 }
297 
298 namespace pragma_test4 {
299 struct A {
300   A();
301   virtual void foo();
302   int a;
303 };
304 
305 // Make sure the pragma applies to class template decls before they've been
306 // instantiated.
307 #pragma vtordisp(push,2)
308 template <typename T>
309 struct B : virtual A {
310   B();
311   virtual ~B();
312   virtual void bar();
313   T b;
314 };
315 #pragma vtordisp(pop)
316 
317 struct C : virtual B<int> { int c; };
318 // CHECK: *** Dumping AST Record Layout
319 // CHECK: *** Dumping AST Record Layout
320 // CHECK: *** Dumping AST Record Layout
321 // CHECK-NEXT:    0 | struct pragma_test4::C
322 // CHECK-NEXT:    0 |   (C vbtable pointer)
323 // CHECK-NEXT:    4 |   int c
324 //   Pragma applies to B, which has vbase A.
325 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
326 // CHECK-NEXT:   12 |   struct pragma_test4::A (virtual base)
327 // CHECK-NEXT:   12 |     (A vftable pointer)
328 // CHECK-NEXT:   16 |     int a
329 //   Pragma does not apply to C, and B doesn't usually need a vtordisp in C.
330 // CHECK-NEXT:   20 |   struct pragma_test4::B<int> (virtual base)
331 // CHECK-NEXT:   20 |     (B vftable pointer)
332 // CHECK-NEXT:   24 |     (B vbtable pointer)
333 // CHECK-NEXT:   28 |     int b
334 // CHECK-NEXT:      | [sizeof=32, align=4
335 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
336 // CHECK-X64: *** Dumping AST Record Layout
337 // CHECK-X64: *** Dumping AST Record Layout
338 // CHECK-X64: *** Dumping AST Record Layout
339 }
340 
341 struct GA {
funGA342 	virtual void fun() {}
343 };
344 struct GB: public GA {};
345 struct GC: public virtual GA {
funGC346 	virtual void fun() {}
GCGC347 	GC() {}
348 };
349 struct GD: public virtual GC, public virtual GB {};
350 
351 // CHECK: *** Dumping AST Record Layout
352 // CHECK: *** Dumping AST Record Layout
353 // CHECK: *** Dumping AST Record Layout
354 // CHECK: *** Dumping AST Record Layout
355 // CHECK-NEXT:    0 | struct GD
356 // CHECK-NEXT:    0 |   (GD vbtable pointer)
357 // CHECK-NEXT:    4 |   (vtordisp for vbase GA)
358 // CHECK-NEXT:    8 |   struct GA (virtual base)
359 // CHECK-NEXT:    8 |     (GA vftable pointer)
360 // CHECK-NEXT:   12 |   struct GC (virtual base)
361 // CHECK-NEXT:   12 |     (GC vbtable pointer)
362 // CHECK-NEXT:   16 |   struct GB (virtual base)
363 // CHECK-NEXT:   16 |     struct GA (primary base)
364 // CHECK-NEXT:   16 |       (GA vftable pointer)
365 // CHECK-NEXT:      | [sizeof=20, align=4
366 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
367 // CHECK-X64: *** Dumping AST Record Layout
368 // CHECK-X64: *** Dumping AST Record Layout
369 // CHECK-X64: *** Dumping AST Record Layout
370 // CHECK-X64: *** Dumping AST Record Layout
371 // CHECK-X64-NEXT:    0 | struct GD
372 // CHECK-X64-NEXT:    0 |   (GD vbtable pointer)
373 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase GA)
374 // CHECK-X64-NEXT:   16 |   struct GA (virtual base)
375 // CHECK-X64-NEXT:   16 |     (GA vftable pointer)
376 // CHECK-X64-NEXT:   24 |   struct GC (virtual base)
377 // CHECK-X64-NEXT:   24 |     (GC vbtable pointer)
378 // CHECK-X64-NEXT:   32 |   struct GB (virtual base)
379 // CHECK-X64-NEXT:   32 |     struct GA (primary base)
380 // CHECK-X64-NEXT:   32 |       (GA vftable pointer)
381 // CHECK-X64-NEXT:      | [sizeof=40, align=8
382 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
383 
384 struct HA {
funHA385   virtual void fun() {}
386 };
387 #pragma vtordisp(push, 2)
388 struct HB : virtual HA {};
389 #pragma vtordisp(pop)
390 #pragma vtordisp(push, 0)
391 struct HC : virtual HB {};
392 #pragma vtordisp(pop)
393 
394 // CHECK: *** Dumping AST Record Layout
395 // CHECK: *** Dumping AST Record Layout
396 // CHECK: *** Dumping AST Record Layout
397 // CHECK-NEXT:    0 | struct HC
398 // CHECK-NEXT:    0 |   (HC vbtable pointer)
399 // CHECK-NEXT:    4 |   (vtordisp for vbase HA)
400 // CHECK-NEXT:    8 |   struct HA (virtual base)
401 // CHECK-NEXT:    8 |     (HA vftable pointer)
402 // CHECK-NEXT:   12 |   struct HB (virtual base)
403 // CHECK-NEXT:   12 |     (HB vbtable pointer)
404 // CHECK-NEXT:      | [sizeof=16, align=4
405 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
406 // CHECK-X64: *** Dumping AST Record Layout
407 // CHECK-X64: *** Dumping AST Record Layout
408 // CHECK-X64: *** Dumping AST Record Layout
409 // CHECK-X64-NEXT:    0 | struct HC
410 // CHECK-X64-NEXT:    0 |   (HC vbtable pointer)
411 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase HA)
412 // CHECK-X64-NEXT:   16 |   struct HA (virtual base)
413 // CHECK-X64-NEXT:   16 |     (HA vftable pointer)
414 // CHECK-X64-NEXT:   24 |   struct HB (virtual base)
415 // CHECK-X64-NEXT:   24 |     (HB vbtable pointer)
416 // CHECK-X64-NEXT:      | [sizeof=32, align=8
417 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
418 
419 struct IA {
420   virtual void f();
421 };
422 struct __declspec(dllexport) IB : virtual IA {
423   virtual void f() = 0;
IBIB424   IB() {}
425 };
426 
427 // CHECK: *** Dumping AST Record Layout
428 // CHECK: *** Dumping AST Record Layout
429 // CHECK-NEXT:    0 | struct IB
430 // CHECK-NEXT:    0 |   (IB vbtable pointer)
431 // CHECK-NEXT:    4 |   struct IA (virtual base)
432 // CHECK-NEXT:    4 |     (IA vftable pointer)
433 // CHECK-NEXT:      | [sizeof=8, align=4
434 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
435 // CHECK-X64: *** Dumping AST Record Layout
436 // CHECK-X64: *** Dumping AST Record Layout
437 // CHECK-X64-NEXT:    0 | struct IB
438 // CHECK-X64-NEXT:    0 |   (IB vbtable pointer)
439 // CHECK-X64-NEXT:    8 |   struct IA (virtual base)
440 // CHECK-X64-NEXT:    8 |     (IA vftable pointer)
441 // CHECK-X64-NEXT:      | [sizeof=16, align=8
442 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
443 
444 int a[
445 sizeof(A)+
446 sizeof(C)+
447 sizeof(D)+
448 sizeof(CT)+
449 sizeof(XC)+
450 sizeof(pragma_test1::C)+
451 sizeof(pragma_test2::C)+
452 sizeof(pragma_test3::C)+
453 sizeof(pragma_test4::C)+
454 sizeof(GD)+
455 sizeof(HC)+
456 sizeof(IB)+
457 0];
458