annotate gcc/testsuite/gcc.dg/builtin-object-size-16.c @ 111:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 /* PR 71831 - __builtin_object_size poor results with no optimization
kono
parents:
diff changeset
2 Verify that even without optimization __builtin_object_size returns
kono
parents:
diff changeset
3 a meaningful result for a subset of simple expressins. In cases
kono
parents:
diff changeset
4 where the result could not easily be made to match the one obtained
kono
parents:
diff changeset
5 with optimization the built-in was made to fail instead. */
kono
parents:
diff changeset
6 /* { dg-do run } */
kono
parents:
diff changeset
7 /* { dg-options "-O0" } */
kono
parents:
diff changeset
8
kono
parents:
diff changeset
9 static int nfails;
kono
parents:
diff changeset
10
kono
parents:
diff changeset
11 #define TEST_FAILURE(line, obj, type, expect, result) \
kono
parents:
diff changeset
12 __builtin_printf ("FAIL: line %i: __builtin_object_size(" \
kono
parents:
diff changeset
13 #obj ", %i) == %zu, got %zu\n", \
kono
parents:
diff changeset
14 line, type, expect, result), ++nfails
kono
parents:
diff changeset
15
kono
parents:
diff changeset
16 #define bos(obj, type) __builtin_object_size (obj, type)
kono
parents:
diff changeset
17 #define size(obj, n) ((size_t)n == X ? sizeof *obj : (size_t)n)
kono
parents:
diff changeset
18
kono
parents:
diff changeset
19 #define test(expect, type, obj) \
kono
parents:
diff changeset
20 do { \
kono
parents:
diff changeset
21 if (bos (obj, type) != size (obj, expect)) \
kono
parents:
diff changeset
22 TEST_FAILURE (__LINE__, obj, type, size (obj, expect), bos (obj, type)); \
kono
parents:
diff changeset
23 } while (0)
kono
parents:
diff changeset
24
kono
parents:
diff changeset
25 #define T(r0, r1, r2, r3, obj) \
kono
parents:
diff changeset
26 do { \
kono
parents:
diff changeset
27 test (r0, 0, obj); \
kono
parents:
diff changeset
28 test (r1, 1, obj); \
kono
parents:
diff changeset
29 test (r2, 2, obj); \
kono
parents:
diff changeset
30 test (r3, 3, obj); \
kono
parents:
diff changeset
31 } while (0)
kono
parents:
diff changeset
32
kono
parents:
diff changeset
33 /* For convenience. Substitute for 'sizeof object' in test cases where
kono
parents:
diff changeset
34 the size can vary from target to target. */
kono
parents:
diff changeset
35 #define X (size_t)0xdeadbeef
kono
parents:
diff changeset
36
kono
parents:
diff changeset
37 /* __builtin_object_size checking results are inconsistent for equivalent
kono
parents:
diff changeset
38 expressions (see bug 71831). To avoid having duplicate the inconsistency
kono
parents:
diff changeset
39 at -O0 the built-in simply fails. The results hardcoded in this test
kono
parents:
diff changeset
40 are those obtained with optimization (for easy comparison) but without
kono
parents:
diff changeset
41 optimization the macros below turn them into expected failures . */
kono
parents:
diff changeset
42 #if __OPTIMIZE__
kono
parents:
diff changeset
43 # define F0(n) n
kono
parents:
diff changeset
44 # define F1(n) n
kono
parents:
diff changeset
45 # define F2(n) n
kono
parents:
diff changeset
46 # define F3(n) n
kono
parents:
diff changeset
47 #else
kono
parents:
diff changeset
48 # define F0(n) -1
kono
parents:
diff changeset
49 # define F1(n) -1
kono
parents:
diff changeset
50 # define F2(n) 0
kono
parents:
diff changeset
51 # define F3(n) 0
kono
parents:
diff changeset
52 #endif
kono
parents:
diff changeset
53
kono
parents:
diff changeset
54 typedef __SIZE_TYPE__ size_t;
kono
parents:
diff changeset
55
kono
parents:
diff changeset
56 extern char ax[];
kono
parents:
diff changeset
57 char ax2[]; /* { dg-warning "assumed to have one element" } */
kono
parents:
diff changeset
58
kono
parents:
diff changeset
59 extern char a0[0];
kono
parents:
diff changeset
60 static char a1[1];
kono
parents:
diff changeset
61 static char a2[2];
kono
parents:
diff changeset
62 static char a9[9];
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64 #if __SIZEOF_SHORT__ == 4
kono
parents:
diff changeset
65 extern short ia0[0];
kono
parents:
diff changeset
66 static short ia1[1];
kono
parents:
diff changeset
67 static short ia9[9];
kono
parents:
diff changeset
68 #elif __SIZEOF_INT__ == 4
kono
parents:
diff changeset
69 extern int ia0[0];
kono
parents:
diff changeset
70 static int ia1[1];
kono
parents:
diff changeset
71 static int ia9[9];
kono
parents:
diff changeset
72 #elif __SIZEOF_LONG__ == 4
kono
parents:
diff changeset
73 extern long ia0[0];
kono
parents:
diff changeset
74 static long ia1[1];
kono
parents:
diff changeset
75 static long ia9[9];
kono
parents:
diff changeset
76 #endif
kono
parents:
diff changeset
77
kono
parents:
diff changeset
78 static char a2x2[2][2];
kono
parents:
diff changeset
79 static char a3x5[3][5];
kono
parents:
diff changeset
80
kono
parents:
diff changeset
81 struct Sx { char n, a[]; } sx;
kono
parents:
diff changeset
82 struct S0 { char n, a[0]; } s0;
kono
parents:
diff changeset
83 struct S1 { char n, a[1]; } s1;
kono
parents:
diff changeset
84 struct S2 { char n, a[2]; } s2;
kono
parents:
diff changeset
85 struct S9 { char n, a[9]; } s9;
kono
parents:
diff changeset
86
kono
parents:
diff changeset
87 struct S2x2 { char n, a[2][2]; } s2x2;
kono
parents:
diff changeset
88 struct S3x5 { char n, a[3][5]; } s3x5;
kono
parents:
diff changeset
89
kono
parents:
diff changeset
90 static __attribute__ ((noclone, noinline)) void
kono
parents:
diff changeset
91 test_arrays ()
kono
parents:
diff changeset
92 {
kono
parents:
diff changeset
93 T ( -1, -1, 0, 0, ax);
kono
parents:
diff changeset
94
kono
parents:
diff changeset
95 T ( 0, 0, 0, 0, a0);
kono
parents:
diff changeset
96 T ( 1, 1, 1, 1, ax2);
kono
parents:
diff changeset
97
kono
parents:
diff changeset
98 T ( 1, 1, 1, 1, a1);
kono
parents:
diff changeset
99 T ( 2, 2, 2, 2, a2);
kono
parents:
diff changeset
100 T ( 9, 9, 9, 9, a9);
kono
parents:
diff changeset
101
kono
parents:
diff changeset
102 T ( 0, 0, 0, 0, a0);
kono
parents:
diff changeset
103 T ( 1, 1, 1, 1, ax2);
kono
parents:
diff changeset
104
kono
parents:
diff changeset
105 T ( 0, 0, 0, 0, ia0);
kono
parents:
diff changeset
106 T ( 4, 4, 4, 4, ia1);
kono
parents:
diff changeset
107 T ( 36, 36, 36, 36, ia9);
kono
parents:
diff changeset
108
kono
parents:
diff changeset
109 /* Not all results for multidimensional arrays make sense (see
kono
parents:
diff changeset
110 bug 77293). The expected results below simply reflect those
kono
parents:
diff changeset
111 obtained at -O2 (modulo the known limitations at -O1). */
kono
parents:
diff changeset
112 T ( 4, 4, 4, 4, a2x2);
kono
parents:
diff changeset
113 T ( 4, 4, 4, 4, &a2x2[0]);
kono
parents:
diff changeset
114 T ( 4, 2, 4, 2, &a2x2[0][0]);
kono
parents:
diff changeset
115 T ( 0, F1 (0), 0, 0, &a2x2 + 1);
kono
parents:
diff changeset
116 T ( 2, F1 ( 2), 2, F3 ( 2), &a2x2[0] + 1);
kono
parents:
diff changeset
117 T ( 3, F1 ( 1), 3, F3 ( 3), &a2x2[0][0] + 1);
kono
parents:
diff changeset
118
kono
parents:
diff changeset
119 T ( 15, 15, 15, 15, a3x5);
kono
parents:
diff changeset
120 T ( 15, 5, 15, 5, &a3x5[0][0] + 0);
kono
parents:
diff changeset
121 T ( 14, F1 ( 4), 14, F3 (14), &a3x5[0][0] + 1);
kono
parents:
diff changeset
122
kono
parents:
diff changeset
123 T ( 1, 1, 1, 1, a1 + 0);
kono
parents:
diff changeset
124 T ( 0, F1 (0), 0, 0, a1 + 1);
kono
parents:
diff changeset
125 T ( 0, F1 ( 0), 0, 0, &a1 + 1);
kono
parents:
diff changeset
126 /* In the following the offset is out of bounds which makes
kono
parents:
diff changeset
127 the expression undefined. Still, verify that the returned
kono
parents:
diff changeset
128 size is zero (and not some large number). */
kono
parents:
diff changeset
129 T ( 0, F1 (0), 0, 0, a1 + 2);
kono
parents:
diff changeset
130
kono
parents:
diff changeset
131 T ( 2, 2, 2, 2, a2 + 0);
kono
parents:
diff changeset
132 T ( 1, F1 ( 1), 1, F3 ( 1), a2 + 1);
kono
parents:
diff changeset
133 T ( 0, F1 ( 0), 0, 0, a2 + 2);
kono
parents:
diff changeset
134 }
kono
parents:
diff changeset
135
kono
parents:
diff changeset
136 static __attribute__ ((noclone, noinline)) void
kono
parents:
diff changeset
137 test_structs (struct Sx *psx, struct S0 *ps0, struct S1 *ps1, struct S9 *ps9)
kono
parents:
diff changeset
138 {
kono
parents:
diff changeset
139 /* The expected size of a declared object with a flexible array member
kono
parents:
diff changeset
140 is sizeof sx in all __builtin_object_size types. */
kono
parents:
diff changeset
141 T ( X, X, X, X, &sx);
kono
parents:
diff changeset
142
kono
parents:
diff changeset
143 /* The expected size of an unknown object with a flexible array member
kono
parents:
diff changeset
144 is unknown in all __builtin_object_size types. */
kono
parents:
diff changeset
145 T ( -1, -1, 0, 0, psx);
kono
parents:
diff changeset
146
kono
parents:
diff changeset
147 /* The expected size of a flexible array member of a declared object
kono
parents:
diff changeset
148 is zero. */
kono
parents:
diff changeset
149 T ( 0, 0, 0, 0, sx.a);
kono
parents:
diff changeset
150
kono
parents:
diff changeset
151 /* The expected size of a flexible array member of an unknown object
kono
parents:
diff changeset
152 is unknown. */
kono
parents:
diff changeset
153 T ( -1, -1, 0, 0, psx->a);
kono
parents:
diff changeset
154
kono
parents:
diff changeset
155 /* The expected size of a declared object with a zero-length array member
kono
parents:
diff changeset
156 is sizeof sx in all __builtin_object_size types. */
kono
parents:
diff changeset
157 T ( X, X, X, X, &s0);
kono
parents:
diff changeset
158
kono
parents:
diff changeset
159 /* The expected size of an unknown object with a zero-length array member
kono
parents:
diff changeset
160 is unknown in all __builtin_object_size types. */
kono
parents:
diff changeset
161 T ( -1, -1, 0, 0, ps0);
kono
parents:
diff changeset
162
kono
parents:
diff changeset
163 /* The expected size of a zero-length array member of a declared object
kono
parents:
diff changeset
164 is zero. */
kono
parents:
diff changeset
165 T ( 0, 0, 0, 0, s0.a);
kono
parents:
diff changeset
166
kono
parents:
diff changeset
167 /* The expected size of a zero-length array member of an unknown object
kono
parents:
diff changeset
168 is unknown. */
kono
parents:
diff changeset
169 T ( -1, -1, 0, 0, ps0->a);
kono
parents:
diff changeset
170
kono
parents:
diff changeset
171 T ( X, X, X, X, &s1);
kono
parents:
diff changeset
172 T ( 1, 1, 1, 1, s1.a);
kono
parents:
diff changeset
173 T ( 0, F1 (0), 0, 0, s1.a + 1);
kono
parents:
diff changeset
174
kono
parents:
diff changeset
175 /* GCC treats arrays of all sizes that are the last member of a struct
kono
parents:
diff changeset
176 as flexible array members. */
kono
parents:
diff changeset
177 T ( -1, -1, 0, 0, ps1);
kono
parents:
diff changeset
178 T ( -1, -1, 0, 0, ps1->a);
kono
parents:
diff changeset
179 T ( -1, -1, 0, 0, ps1->a + 1);
kono
parents:
diff changeset
180
kono
parents:
diff changeset
181 T ( X, X, X, X, &s9);
kono
parents:
diff changeset
182 T ( 9, 9, 9, 9, s9.a);
kono
parents:
diff changeset
183 T ( 9, 9, 9, 9, s9.a + 0);
kono
parents:
diff changeset
184 T ( 8, F1 ( 8), 8, F3 ( 8), s9.a + 1);
kono
parents:
diff changeset
185 T ( 7, F1 ( 7), 7, F3 ( 7), s9.a + 2);
kono
parents:
diff changeset
186 T ( 0, F1 ( 0), 0, F3 ( 0), s9.a + 9);
kono
parents:
diff changeset
187
kono
parents:
diff changeset
188 /* The following make little sense but see bug 77301. */
kono
parents:
diff changeset
189 T ( -1, -1, 0, 0, ps9);
kono
parents:
diff changeset
190 T ( -1, -1, 0, 0, ps9->a);
kono
parents:
diff changeset
191 T ( -1, -1, 0, 0, ps9->a + 1);
kono
parents:
diff changeset
192 }
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 int
kono
parents:
diff changeset
195 main()
kono
parents:
diff changeset
196 {
kono
parents:
diff changeset
197 test_arrays ();
kono
parents:
diff changeset
198
kono
parents:
diff changeset
199 test_structs (&sx, &s0, &s1, &s9);
kono
parents:
diff changeset
200
kono
parents:
diff changeset
201 if (nfails)
kono
parents:
diff changeset
202 __builtin_abort ();
kono
parents:
diff changeset
203
kono
parents:
diff changeset
204 return 0;
kono
parents:
diff changeset
205 }