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 ASSERT( sizeof(size2b_bf) >= 2);
106 ASSERT( sizeof(size2c_bf) >= 2);
107 ASSERT( sizeof(size2d_bf) >= 2);
108 ASSERT( sizeof(size3a_bf) >= 2);
109 ASSERT( sizeof(size1a_bf) <= sizeof(size1b_bf));
111 /* Some SDCC specific assertions. SDCC uses 8 bit storage units.
112 Bitfields that are less than 8 bits, but would (due to earlier
113 bitfield declarations) span a storage unit boundary are
114 realigned to the next storage unit boundary. Bitfields of
115 8 or greater bits are always aligned to start on a storage
119 ASSERT( sizeof(size1a_bf) == 1);
120 ASSERT( sizeof(size1b_bf) == 1);
121 ASSERT( sizeof(size1c_bf) == 1);
122 ASSERT( sizeof(size2a_bf) == 2);
123 ASSERT( sizeof(size2b_bf) == 2);
124 ASSERT( sizeof(size2c_bf) == 2);
125 ASSERT( sizeof(size2d_bf) == 2);
126 ASSERT( sizeof(size3a_bf) == 3);
132 testBitfieldsSingleBitLiteral(void)
145 /* make sure modulo 2 truncation works */
146 size2b_bf.b0 = 0x3fe;
147 ASSERT(size2b_bf.b0==0);
148 ASSERT(size2b_bf.b1==0);
149 ASSERT(size2b_bf.b2==0);
150 ASSERT(size2b_bf.b3==0);
151 ASSERT(size2b_bf.b4==0);
152 ASSERT(size2b_bf.b5==0);
153 ASSERT(size2b_bf.b6==0);
154 ASSERT(size2b_bf.b7==0);
155 ASSERT(size2b_bf.b8==0);
156 ASSERT(size2b_bf.b9==0);
157 size2b_bf.b0 = 0x3ff;
158 ASSERT(size2b_bf.b0==1);
159 ASSERT(size2b_bf.b1==0);
160 ASSERT(size2b_bf.b2==0);
161 ASSERT(size2b_bf.b3==0);
162 ASSERT(size2b_bf.b4==0);
163 ASSERT(size2b_bf.b5==0);
164 ASSERT(size2b_bf.b6==0);
165 ASSERT(size2b_bf.b7==0);
166 ASSERT(size2b_bf.b8==0);
167 ASSERT(size2b_bf.b9==0);
169 /* make sure both bytes work */
170 size2b_bf.b9 = 0x3ff;
171 ASSERT(size2b_bf.b0==1);
172 ASSERT(size2b_bf.b1==0);
173 ASSERT(size2b_bf.b2==0);
174 ASSERT(size2b_bf.b3==0);
175 ASSERT(size2b_bf.b4==0);
176 ASSERT(size2b_bf.b5==0);
177 ASSERT(size2b_bf.b6==0);
178 ASSERT(size2b_bf.b7==0);
179 ASSERT(size2b_bf.b8==0);
180 ASSERT(size2b_bf.b9==1);
184 testBitfieldsSingleBit(void)
186 volatile unsigned char c;
200 /* make sure modulo 2 truncation works */
203 ASSERT(size2b_bf.b0==0);
204 ASSERT(size2b_bf.b1==0);
205 ASSERT(size2b_bf.b2==0);
206 ASSERT(size2b_bf.b3==0);
207 ASSERT(size2b_bf.b4==0);
208 ASSERT(size2b_bf.b5==0);
209 ASSERT(size2b_bf.b6==0);
210 ASSERT(size2b_bf.b7==0);
211 ASSERT(size2b_bf.b8==0);
212 ASSERT(size2b_bf.b9==0);
215 ASSERT(size2b_bf.b0==1);
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);
226 /* make sure both bytes work */
228 ASSERT(size2b_bf.b0==1);
229 ASSERT(size2b_bf.b1==0);
230 ASSERT(size2b_bf.b2==0);
231 ASSERT(size2b_bf.b3==0);
232 ASSERT(size2b_bf.b4==0);
233 ASSERT(size2b_bf.b5==0);
234 ASSERT(size2b_bf.b6==0);
235 ASSERT(size2b_bf.b7==0);
236 ASSERT(size2b_bf.b8==0);
237 ASSERT(size2b_bf.b9==1);
241 testBitfieldsMultibitLiteral(void)
243 size2c_bf.b0 = 0xff; /* should truncate to 0x0f */
245 ASSERT(size2c_bf.b0==0x0f);
246 ASSERT(size2c_bf.b1==0);
248 size2c_bf.b1 = 0xff; /* should truncate to 0x1f */
250 ASSERT(size2c_bf.b0==0);
251 ASSERT(size2c_bf.b1==0x1f);
253 size2c_bf.b0 = 0xff; /* should truncate to 0x0f */
254 size2c_bf.b1 = 0xff; /* should truncate to 0x1f */
255 ASSERT(size2c_bf.b0==0x0f);
256 ASSERT(size2c_bf.b1==0x1f);
258 size2d_bf.b0 = 0xffff; /* should truncate to 0x0fff */
260 ASSERT(size2d_bf.b0==0x0fff);
261 ASSERT(size2d_bf.b1==0);
263 size2d_bf.b1 = 0xffff; /* should truncate to 0x07 */
265 ASSERT(size2d_bf.b0==0);
266 ASSERT(size2d_bf.b1==0x07);
268 size2d_bf.b0 = 0xffff; /* should truncate to 0x0fff */
269 size2d_bf.b1 = 0xffff; /* should truncate to 0x07 */
270 ASSERT(size2d_bf.b0==0x0fff);
271 ASSERT(size2d_bf.b1==0x07);
273 size2d_bf.b0 = 0x0321;
275 ASSERT(size2d_bf.b0==0x0321);
276 ASSERT(size2d_bf.b1==1);
278 size2d_bf.b0 = 0x0a46;
280 ASSERT(size2d_bf.b0==0x0a46);
281 ASSERT(size2d_bf.b1==5);
285 testBitfieldsMultibit(void)
287 volatile int allones = 0xffff;
288 volatile int zero = 0;
291 size2c_bf.b0 = allones; /* should truncate to 0x0f */
293 ASSERT(size2c_bf.b0==0x0f);
294 ASSERT(size2c_bf.b1==0);
296 size2c_bf.b1 = allones; /* should truncate to 0x1f */
298 ASSERT(size2c_bf.b0==0);
299 ASSERT(size2c_bf.b1==0x1f);
301 size2d_bf.b0 = allones; /* should truncate to 0x0fff */
303 ASSERT(size2d_bf.b0==0x0fff);
304 ASSERT(size2d_bf.b1==0);
306 size2d_bf.b1 = allones; /* should truncate to 0x07 */
308 ASSERT(size2d_bf.b0==0);
309 ASSERT(size2d_bf.b1==0x07);
315 ASSERT(size2d_bf.b0==0x0321);
316 ASSERT(size2d_bf.b1==1);
322 ASSERT(size2d_bf.b0==0x0a46);
323 ASSERT(size2d_bf.b1==5);
331 ASSERT(*(char *)(&c_bf) == (2 + (3<<3)) );
336 ASSERT(*(int *)(&i_bf) == (23 + (234<<7)) );
338 l_bitfield.l0_7 = 23;
339 l_bitfield.l7_10 = 234;
340 l_bitfield.l17_15 = 2345;
341 ASSERT(*(long *)(&l_bf) == (23 + (234<<7) + (2345<<17)) );
346 testSignedBitfields(void)
348 #if !defined(SDCC_hc08) && !defined(SDCC_z80) && !defined(SDCC_gbz80)
352 ASSERT(s_bf.s0_7 == -16);
353 ASSERT(s_bf.s7_1 == - 1);
354 ASSERT(s_bf.s8_9 == - 8);
355 ASSERT(s_bf.s0_7 < 0);
356 ASSERT(s_bf.s7_1 < 0);
357 ASSERT(s_bf.s8_9 < 0);
362 ASSERT(s_bf.s0_7 == 0x3f);
363 ASSERT(s_bf.s7_1 == 0);
364 ASSERT(s_bf.s8_9 == 0xff);
365 ASSERT(s_bf.s0_7 > 0);
366 ASSERT(s_bf.s8_9 > 0);