git.gag.com Git - debian/cc1111/blob - support/regression/tests/bitfields.c

   1 /** Bitfield tests.
   2
   3   SDCC pic16 port currently does not support bitfields of size > 8,
   4   so they are ifdefed out.
   5 */
   6 #include <testfwk.h>
   7
   8 struct {
   9   char c0_3 : 3;
  10   char c3_5 : 5;
  11 } c_bf;
  12
  13 #if !defined(SDCC_pic16)
  14 struct {
  15   int i0_7 : 7;
  16   int i7_9 : 9;
  17 } i_bf;
  18
  19 struct {
  20   long l0_7 : 7;
  21   long l7_10 : 10;
  22   long l17_15 : 15;
  23 } l_bf;
  24
  25 struct {
  26   unsigned int b0 : 1;
  27   unsigned int b1 : 1;
  28   unsigned int b2 : 1;
  29   unsigned int b3 : 1;
  30   unsigned int b4 : 1;
  31   unsigned int b5 : 1;
  32   unsigned int b6 : 1;
  33   unsigned int b7 : 1;
  34   unsigned int b8 : 1;
  35   unsigned int b9 : 1;
  36 } sb_bf;
  37 #endif  /* !SDCC_pic16 */
  38
  39 struct {
  40   unsigned int b0 : 1;
  41   unsigned int b2 : 1;
  42 } size1a_bf;
  43
  44 struct {
  45   unsigned int b0 : 1;
  46   unsigned int b1 : 1;
  47   unsigned int    : 0;
  48 } size1b_bf;
  49
  50 struct {
  51   unsigned int b0 : 1;
  52   unsigned int b1 : 1;
  53   unsigned int b2 : 6;
  54 } size1c_bf;
  55
  56 struct {
  57   unsigned int b0 : 1;
  58   unsigned int    : 0;
  59   unsigned int b1 : 1;
  60 } size2a_bf;
  61
  62 #if !defined(SDCC_pic16)
  63 struct {
  64   unsigned int b0 : 1;
  65   unsigned int b1 : 1;
  66   unsigned int b2 : 1;
  67   unsigned int b3 : 1;
  68   unsigned int b4 : 1;
  69   unsigned int b5 : 1;
  70   unsigned int b6 : 1;
  71   unsigned int b7 : 1;
  72   unsigned int b8 : 1;
  73   unsigned int b9 : 1;
  74 } size2b_bf;
  75
  76 struct {
  77   unsigned int b0 : 4;
  78   unsigned int b1 : 5;
  79 } size2c_bf;
  80
  81 struct {
  82   unsigned int b0 : 12;
  83   unsigned int b1 : 3;
  84 } size2d_bf;
  85
  86 struct {
  87   unsigned int b0 : 3;
  88   unsigned int b1 : 12;
  89 } size3a_bf;
  90
  91
  92 struct {
  93   signed int s0_7  : 7;
  94   signed int s7_1  : 1;
  95   signed int s8_9  : 9;
  96 } s_bf;
  97 #endif  /* !SDCC_pic16 */
  98
  99 void
 100 testBitfieldSizeof(void)
 101 {
 102   /* Although bitfields are extremely implementation dependant, these
 103      assertions should hold for all implementations with storage units
 104      of 8 bits or larger (nearly universal).
 105   */
 106   ASSERT( sizeof(size1a_bf) >= 1);
 107   ASSERT( sizeof(size1b_bf) >= 1);
 108   ASSERT( sizeof(size1c_bf) >= 1);
 109 #if !defined(SDCC_pic16)
 110   ASSERT( sizeof(size2b_bf) >= 2);
 111   ASSERT( sizeof(size2c_bf) >= 2);
 112   ASSERT( sizeof(size2d_bf) >= 2);
 113   ASSERT( sizeof(size3a_bf) >= 2);
 114   ASSERT( sizeof(size1a_bf) <= sizeof(size1b_bf));
 115 #endif  /* !SDCC_pic16 */
 116   /* Some SDCC specific assertions. SDCC uses 8 bit storage units.
 117      Bitfields that are less than 8 bits, but would (due to earlier
 118      bitfield declarations) span a storage unit boundary are
 119      realigned to the next storage unit boundary. Bitfields of
 120      8 or greater bits are always aligned to start on a storage
 121      unit boundary.
 122   */
 123 #ifdef SDCC
 124   ASSERT( sizeof(size1a_bf) == 1);
 125   ASSERT( sizeof(size1b_bf) == 1);
 126   ASSERT( sizeof(size1c_bf) == 1);
 127   ASSERT( sizeof(size2a_bf) == 2);
 128 #if !defined(SDCC_pic16)
 129   ASSERT( sizeof(size2b_bf) == 2);
 130   ASSERT( sizeof(size2c_bf) == 2);
 131   ASSERT( sizeof(size2d_bf) == 2);
 132   ASSERT( sizeof(size3a_bf) == 3);
 133 #endif  /* !SDCC_pic16 */
 134 #endif
 135 }
 136
 137
 138 void
 139 testBitfieldsSingleBitLiteral(void)
 140 {
 141 #if !defined(SDCC_pic16)
 142   size2b_bf.b0 = 0;
 143   size2b_bf.b1 = 0;
 144   size2b_bf.b2 = 0;
 145   size2b_bf.b3 = 0;
 146   size2b_bf.b4 = 0;
 147   size2b_bf.b5 = 0;
 148   size2b_bf.b6 = 0;
 149   size2b_bf.b7 = 0;
 150   size2b_bf.b8 = 0;
 151   size2b_bf.b9 = 0;
 152
 153   /* make sure modulo 2 truncation works */
 154   size2b_bf.b0 = 0x3fe;
 155   ASSERT(size2b_bf.b0==0);
 156   ASSERT(size2b_bf.b1==0);
 157   ASSERT(size2b_bf.b2==0);
 158   ASSERT(size2b_bf.b3==0);
 159   ASSERT(size2b_bf.b4==0);
 160   ASSERT(size2b_bf.b5==0);
 161   ASSERT(size2b_bf.b6==0);
 162   ASSERT(size2b_bf.b7==0);
 163   ASSERT(size2b_bf.b8==0);
 164   ASSERT(size2b_bf.b9==0);
 165   size2b_bf.b0 = 0x3ff;
 166   ASSERT(size2b_bf.b0==1);
 167   ASSERT(size2b_bf.b1==0);
 168   ASSERT(size2b_bf.b2==0);
 169   ASSERT(size2b_bf.b3==0);
 170   ASSERT(size2b_bf.b4==0);
 171   ASSERT(size2b_bf.b5==0);
 172   ASSERT(size2b_bf.b6==0);
 173   ASSERT(size2b_bf.b7==0);
 174   ASSERT(size2b_bf.b8==0);
 175   ASSERT(size2b_bf.b9==0);
 176
 177   /* make sure both bytes work */
 178   size2b_bf.b9 = 0x3ff;
 179   ASSERT(size2b_bf.b0==1);
 180   ASSERT(size2b_bf.b1==0);
 181   ASSERT(size2b_bf.b2==0);
 182   ASSERT(size2b_bf.b3==0);
 183   ASSERT(size2b_bf.b4==0);
 184   ASSERT(size2b_bf.b5==0);
 185   ASSERT(size2b_bf.b6==0);
 186   ASSERT(size2b_bf.b7==0);
 187   ASSERT(size2b_bf.b8==0);
 188   ASSERT(size2b_bf.b9==1);
 189 #endif  /* !SDCC_pic16 */
 190 }
 191
 192 void
 193 testBitfieldsSingleBit(void)
 194 {
 195 #if !defined(SDCC_pic16)
 196   volatile unsigned char c;
 197
 198   c = 0;
 199   size2b_bf.b0 = c;
 200   size2b_bf.b1 = c;
 201   size2b_bf.b2 = c;
 202   size2b_bf.b3 = c;
 203   size2b_bf.b4 = c;
 204   size2b_bf.b5 = c;
 205   size2b_bf.b6 = c;
 206   size2b_bf.b7 = c;
 207   size2b_bf.b8 = c;
 208   size2b_bf.b9 = c;
 209
 210   /* make sure modulo 2 truncation works */
 211   c = 0xfe;
 212   size2b_bf.b0 = c;
 213   ASSERT(size2b_bf.b0==0);
 214   ASSERT(size2b_bf.b1==0);
 215   ASSERT(size2b_bf.b2==0);
 216   ASSERT(size2b_bf.b3==0);
 217   ASSERT(size2b_bf.b4==0);
 218   ASSERT(size2b_bf.b5==0);
 219   ASSERT(size2b_bf.b6==0);
 220   ASSERT(size2b_bf.b7==0);
 221   ASSERT(size2b_bf.b8==0);
 222   ASSERT(size2b_bf.b9==0);
 223   c++;
 224   size2b_bf.b0 = c;
 225   ASSERT(size2b_bf.b0==1);
 226   ASSERT(size2b_bf.b1==0);
 227   ASSERT(size2b_bf.b2==0);
 228   ASSERT(size2b_bf.b3==0);
 229   ASSERT(size2b_bf.b4==0);
 230   ASSERT(size2b_bf.b5==0);
 231   ASSERT(size2b_bf.b6==0);
 232   ASSERT(size2b_bf.b7==0);
 233   ASSERT(size2b_bf.b8==0);
 234   ASSERT(size2b_bf.b9==0);
 235
 236   /* make sure both bytes work */
 237   size2b_bf.b9 = c;
 238   ASSERT(size2b_bf.b0==1);
 239   ASSERT(size2b_bf.b1==0);
 240   ASSERT(size2b_bf.b2==0);
 241   ASSERT(size2b_bf.b3==0);
 242   ASSERT(size2b_bf.b4==0);
 243   ASSERT(size2b_bf.b5==0);
 244   ASSERT(size2b_bf.b6==0);
 245   ASSERT(size2b_bf.b7==0);
 246   ASSERT(size2b_bf.b8==0);
 247   ASSERT(size2b_bf.b9==1);
 248 #endif  /* !SDCC_pic16 */
 249 }
 250
 251 void
 252 testBitfieldsMultibitLiteral(void)
 253 {
 254 #if !defined(SDCC_pic16)
 255   size2c_bf.b0 = 0xff;  /* should truncate to 0x0f */
 256   size2c_bf.b1 = 0;
 257   ASSERT(size2c_bf.b0==0x0f);
 258   ASSERT(size2c_bf.b1==0);
 259
 260   size2c_bf.b1 = 0xff;  /* should truncate to 0x1f */
 261   size2c_bf.b0 = 0;
 262   ASSERT(size2c_bf.b0==0);
 263   ASSERT(size2c_bf.b1==0x1f);
 264
 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);
 269
 270   size2d_bf.b0 = 0xffff; /* should truncate to 0x0fff */
 271   size2d_bf.b1 = 0;
 272   ASSERT(size2d_bf.b0==0x0fff);
 273   ASSERT(size2d_bf.b1==0);
 274
 275   size2d_bf.b1 = 0xffff; /* should truncate to 0x07 */
 276   size2d_bf.b0 = 0;
 277   ASSERT(size2d_bf.b0==0);
 278   ASSERT(size2d_bf.b1==0x07);
 279
 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);
 284
 285   size2d_bf.b0 = 0x0321;
 286   size2d_bf.b1 = 1;
 287   ASSERT(size2d_bf.b0==0x0321);
 288   ASSERT(size2d_bf.b1==1);
 289
 290   size2d_bf.b0 = 0x0a46;
 291   size2d_bf.b1 = 5;
 292   ASSERT(size2d_bf.b0==0x0a46);
 293   ASSERT(size2d_bf.b1==5);
 294 #endif  /* !SDCC_pic16 */
 295 }
 296
 297 void
 298 testBitfieldsMultibit(void)
 299 {
 300 #if !defined(SDCC_pic16)
 301   volatile int allones = 0xffff;
 302   volatile int zero = 0;
 303   volatile int x;
 304
 305   size2c_bf.b0 = allones;       /* should truncate to 0x0f */
 306   size2c_bf.b1 = zero;
 307   ASSERT(size2c_bf.b0==0x0f);
 308   ASSERT(size2c_bf.b1==0);
 309
 310   size2c_bf.b1 = allones;       /* should truncate to 0x1f */
 311   size2c_bf.b0 = zero;
 312   ASSERT(size2c_bf.b0==0);
 313   ASSERT(size2c_bf.b1==0x1f);
 314
 315   size2d_bf.b0 = allones; /* should truncate to 0x0fff */
 316   size2d_bf.b1 = zero;
 317   ASSERT(size2d_bf.b0==0x0fff);
 318   ASSERT(size2d_bf.b1==0);
 319
 320   size2d_bf.b1 = allones; /* should truncate to 0x07 */
 321   size2d_bf.b0 = zero;
 322   ASSERT(size2d_bf.b0==0);
 323   ASSERT(size2d_bf.b1==0x07);
 324
 325   x = 0x0321;
 326   size2d_bf.b0 = x;
 327   x = 1;
 328   size2d_bf.b1 = x;
 329   ASSERT(size2d_bf.b0==0x0321);
 330   ASSERT(size2d_bf.b1==1);
 331
 332   x = 0x0a46;
 333   size2d_bf.b0 = x;
 334   x = 5;
 335   size2d_bf.b1 = x;
 336   ASSERT(size2d_bf.b0==0x0a46);
 337   ASSERT(size2d_bf.b1==5);
 338 #endif  /* !SDCC_pic16 */
 339 }
 340
 341 void
 342 testBitfields(void)
 343 {
 344   c_bf.c0_3 = 2;
 345   c_bf.c3_5 = 3;
 346 #if defined(PORT_HOST) && (defined(__ppc__) || defined(__PPC__))
 347   /* bitfields on powerpc architecture are allocated from left to right */
 348   ASSERT(*(char *)(&c_bf) == ((2<<(8-3)) + 3) );
 349 #else
 350   ASSERT(*(char *)(&c_bf) == (2 + (3<<3)) );
 351 #endif
 352
 353 #if 0 // not yet
 354   i_bf.i0_7 = 23;
 355   i_bf.i7_9 = 234;
 356   ASSERT(*(int *)(&i_bf) == (23 + (234<<7)) );
 357
 358   l_bitfield.l0_7 = 23;
 359   l_bitfield.l7_10 = 234;
 360   l_bitfield.l17_15 = 2345;
 361   ASSERT(*(long *)(&l_bf) == (23 + (234<<7) + (2345<<17)) );
 362 #endif
 363 }
 364
 365 void
 366 testSignedBitfields(void)
 367 {
 368 #if !defined(SDCC_pic16)
 369   s_bf.s0_7 =   0xf0;
 370   s_bf.s7_1 =      1;
 371   s_bf.s8_9 = 0xfff8;
 372   ASSERT(s_bf.s0_7 == -16);
 373   ASSERT(s_bf.s7_1 == - 1);
 374   ASSERT(s_bf.s8_9 == - 8);
 375   ASSERT(s_bf.s0_7 < 0);
 376   ASSERT(s_bf.s7_1 < 0);
 377   ASSERT(s_bf.s8_9 < 0);
 378
 379   s_bf.s0_7 =   0x3f;
 380   s_bf.s7_1 =      2;
 381   s_bf.s8_9 = 0x00ff;
 382   ASSERT(s_bf.s0_7 == 0x3f);
 383   ASSERT(s_bf.s7_1 ==    0);
 384   ASSERT(s_bf.s8_9 == 0xff);
 385   ASSERT(s_bf.s0_7 > 0);
 386   ASSERT(s_bf.s8_9 > 0);
 387 #endif  /* !SDCC_pic16 */
 388 }
 389
 390 /* test case for enhancement request #2291335 : Unnamed bit-field initialization */
 391
 392 struct s2291335_1 {
 393   int a : 2;
 394   char  : 2;
 395   int b : 2;
 396 };
 397
 398 struct s2291335_2 {
 399   int a : 2;
 400   char  : 0;
 401   int b : 2;
 402 };
 403
 404 struct s2291335_1 gs2291335_1 = {1, 2};
 405 struct s2291335_2 gs2291335_2 = {1, 2};
 406
 407 void
 408 __test2291335(void)
 409 {
 410   struct s2291335_1 ls2291335_1 = {1, 2};
 411   struct s2291335_2 ls2291335_2 = {1, 2};
 412
 413   ASSERT(gs2291335_1.a == 1);
 414   ASSERT(gs2291335_1.b == 2);
 415   ASSERT(gs2291335_2.a == 1);
 416   ASSERT(gs2291335_2.b == 2);
 417
 418   ASSERT(ls2291335_1.a == 1);
 419   ASSERT(ls2291335_1.b == 2);
 420   ASSERT(ls2291335_2.a == 1);
 421   ASSERT(ls2291335_2.b == 2);
 422 }
 423
 424 /* test case for bug #2366757: segfault when initializing structure with bitfield */
 425
 426 struct
 427 {
 428   char a : 1;
 429   char b : 1;
 430 } s2366757 = {0};