96 testBitfieldSizeof(void)
98 /* Although bitfields are extremely implementation dependant, these
99 assertions should hold for all implementations with storage units
100 of 8 bits or larger (nearly universal).
102 ASSERT( sizeof(size1a_bf) >= 1);
103 ASSERT( sizeof(size1b_bf) >= 1);
104 ASSERT( sizeof(size1c_bf) >= 1);
105 #if !defined (__amd64__) && !defined(__CYGWIN32__) && !defined(__MINGW32__)
106 /* assertion fails on amd64, cygwin and mingw.
107 Maybe it depends on gcc version?
109 ASSERT( sizeof(size2a_bf) >= 2);
111 ASSERT( sizeof(size2b_bf) >= 2);
112 ASSERT( sizeof(size2c_bf) >= 2);
113 ASSERT( sizeof(size2d_bf) >= 2);
114 ASSERT( sizeof(size3a_bf) >= 2);
115 ASSERT( sizeof(size1a_bf) <= sizeof(size1b_bf));
116 #if !defined (__amd64__) && !defined(__CYGWIN32__) && !defined(__MINGW32__)
117 /* assertion fails on amd64, cygwin and mingw.
118 Maybe it depends on gcc version?
120 ASSERT( sizeof(size1a_bf) < sizeof(size2a_bf));
123 /* Some SDCC specific assertions. SDCC uses 8 bit storage units.
124 Bitfields that are less than 8 bits, but would (due to earlier
125 bitfield declarations) span a storage unit boundary are
126 realigned to the next storage unit boundary. Bitfields of
127 8 or greater bits are always aligned to start on a storage
131 ASSERT( sizeof(size1a_bf) == 1);
132 ASSERT( sizeof(size1b_bf) == 1);
133 ASSERT( sizeof(size1c_bf) == 1);
134 ASSERT( sizeof(size2a_bf) == 2);
135 ASSERT( sizeof(size2b_bf) == 2);
136 ASSERT( sizeof(size2c_bf) == 2);
137 ASSERT( sizeof(size2d_bf) == 2);
138 ASSERT( sizeof(size3a_bf) == 3);
144 testBitfieldsSingleBitLiteral(void)
157 /* make sure modulo 2 truncation works */
158 size2b_bf.b0 = 0x3fe;
159 ASSERT(size2b_bf.b0==0);
160 ASSERT(size2b_bf.b1==0);
161 ASSERT(size2b_bf.b2==0);
162 ASSERT(size2b_bf.b3==0);
163 ASSERT(size2b_bf.b4==0);
164 ASSERT(size2b_bf.b5==0);
165 ASSERT(size2b_bf.b6==0);
166 ASSERT(size2b_bf.b7==0);
167 ASSERT(size2b_bf.b8==0);
168 ASSERT(size2b_bf.b9==0);
169 size2b_bf.b0 = 0x3ff;
170 ASSERT(size2b_bf.b0==1);
171 ASSERT(size2b_bf.b1==0);
172 ASSERT(size2b_bf.b2==0);
173 ASSERT(size2b_bf.b3==0);
174 ASSERT(size2b_bf.b4==0);
175 ASSERT(size2b_bf.b5==0);
176 ASSERT(size2b_bf.b6==0);
177 ASSERT(size2b_bf.b7==0);
178 ASSERT(size2b_bf.b8==0);
179 ASSERT(size2b_bf.b9==0);
181 /* make sure both bytes work */
182 size2b_bf.b9 = 0x3ff;
183 ASSERT(size2b_bf.b0==1);
184 ASSERT(size2b_bf.b1==0);
185 ASSERT(size2b_bf.b2==0);
186 ASSERT(size2b_bf.b3==0);
187 ASSERT(size2b_bf.b4==0);
188 ASSERT(size2b_bf.b5==0);
189 ASSERT(size2b_bf.b6==0);
190 ASSERT(size2b_bf.b7==0);
191 ASSERT(size2b_bf.b8==0);
192 ASSERT(size2b_bf.b9==1);
196 testBitfieldsSingleBit(void)
198 volatile unsigned char c;
212 /* make sure modulo 2 truncation works */
215 ASSERT(size2b_bf.b0==0);
216 ASSERT(size2b_bf.b1==0);
217 ASSERT(size2b_bf.b2==0);
218 ASSERT(size2b_bf.b3==0);
219 ASSERT(size2b_bf.b4==0);
220 ASSERT(size2b_bf.b5==0);
221 ASSERT(size2b_bf.b6==0);
222 ASSERT(size2b_bf.b7==0);
223 ASSERT(size2b_bf.b8==0);
224 ASSERT(size2b_bf.b9==0);
227 ASSERT(size2b_bf.b0==1);
228 ASSERT(size2b_bf.b1==0);
229 ASSERT(size2b_bf.b2==0);
230 ASSERT(size2b_bf.b3==0);
231 ASSERT(size2b_bf.b4==0);
232 ASSERT(size2b_bf.b5==0);
233 ASSERT(size2b_bf.b6==0);
234 ASSERT(size2b_bf.b7==0);
235 ASSERT(size2b_bf.b8==0);
236 ASSERT(size2b_bf.b9==0);
238 /* make sure both bytes work */
240 ASSERT(size2b_bf.b0==1);
241 ASSERT(size2b_bf.b1==0);
242 ASSERT(size2b_bf.b2==0);
243 ASSERT(size2b_bf.b3==0);
244 ASSERT(size2b_bf.b4==0);
245 ASSERT(size2b_bf.b5==0);
246 ASSERT(size2b_bf.b6==0);
247 ASSERT(size2b_bf.b7==0);
248 ASSERT(size2b_bf.b8==0);
249 ASSERT(size2b_bf.b9==1);
253 testBitfieldsMultibitLiteral(void)
255 size2c_bf.b0 = 0xff; /* should truncate to 0x0f */
257 ASSERT(size2c_bf.b0==0x0f);
258 ASSERT(size2c_bf.b1==0);
260 size2c_bf.b1 = 0xff; /* should truncate to 0x1f */
262 ASSERT(size2c_bf.b0==0);
263 ASSERT(size2c_bf.b1==0x1f);
265 size2c_bf.b0 = 0xff; /* should truncate to 0x0f */
266 size2c_bf.b1 = 0xff; /* should truncate to 0x1f */
267 ASSERT(size2c_bf.b0==0x0f);
268 ASSERT(size2c_bf.b1==0x1f);
270 size2d_bf.b0 = 0xffff; /* should truncate to 0x0fff */
272 ASSERT(size2d_bf.b0==0x0fff);
273 ASSERT(size2d_bf.b1==0);
275 size2d_bf.b1 = 0xffff; /* should truncate to 0x07 */
277 ASSERT(size2d_bf.b0==0);
278 ASSERT(size2d_bf.b1==0x07);
280 size2d_bf.b0 = 0xffff; /* should truncate to 0x0fff */
281 size2d_bf.b1 = 0xffff; /* should truncate to 0x07 */
282 ASSERT(size2d_bf.b0==0x0fff);
283 ASSERT(size2d_bf.b1==0x07);
285 size2d_bf.b0 = 0x0321;
287 ASSERT(size2d_bf.b0==0x0321);
288 ASSERT(size2d_bf.b1==1);
290 size2d_bf.b0 = 0x0a46;
292 ASSERT(size2d_bf.b0==0x0a46);
293 ASSERT(size2d_bf.b1==5);
297 testBitfieldsMultibit(void)
299 volatile int allones = 0xffff;
300 volatile int zero = 0;
303 size2c_bf.b0 = allones; /* should truncate to 0x0f */
305 ASSERT(size2c_bf.b0==0x0f);
306 ASSERT(size2c_bf.b1==0);
308 size2c_bf.b1 = allones; /* should truncate to 0x1f */
310 ASSERT(size2c_bf.b0==0);
311 ASSERT(size2c_bf.b1==0x1f);
313 size2d_bf.b0 = allones; /* should truncate to 0x0fff */
315 ASSERT(size2d_bf.b0==0x0fff);
316 ASSERT(size2d_bf.b1==0);
318 size2d_bf.b1 = allones; /* should truncate to 0x07 */
320 ASSERT(size2d_bf.b0==0);
321 ASSERT(size2d_bf.b1==0x07);
327 ASSERT(size2d_bf.b0==0x0321);
328 ASSERT(size2d_bf.b1==1);
334 ASSERT(size2d_bf.b0==0x0a46);
335 ASSERT(size2d_bf.b1==5);
343 ASSERT(*(char *)(&c_bf) == (2 + (3<<3)) );
348 ASSERT(*(int *)(&i_bf) == (23 + (234<<7)) );
350 l_bitfield.l0_7 = 23;
351 l_bitfield.l7_10 = 234;
352 l_bitfield.l17_15 = 2345;
353 ASSERT(*(long *)(&l_bf) == (23 + (234<<7) + (2345<<17)) );
358 testSignedBitfields(void)
360 #if !defined(SDCC_hc08) && !defined(SDCC_z80) && !defined(SDCC_gbz80)
364 ASSERT(s_bf.s0_7 == -16);
365 ASSERT(s_bf.s7_1 == - 1);
366 ASSERT(s_bf.s8_9 == - 8);
367 ASSERT(s_bf.s0_7 < 0);
368 ASSERT(s_bf.s7_1 < 0);
369 ASSERT(s_bf.s8_9 < 0);
374 ASSERT(s_bf.s0_7 == 0x3f);
375 ASSERT(s_bf.s7_1 == 0);
376 ASSERT(s_bf.s8_9 == 0xff);
377 ASSERT(s_bf.s0_7 > 0);
378 ASSERT(s_bf.s8_9 > 0);