gcc/testsuite/gcc.target/i386/iamcu/test_bitfields.c

   1 /* This is a small test to see if bitfields are working.  It is only a
   2    few structs and a union and a test to see if they have the correct
   3    size, if values can be read and written and a couple of argument
   4    passing tests.  No alignment testing is done.  */
   5
   6 #include "defines.h"
   7 #include "macros.h"
   8
   9
  10 /* These five bitfields are taken from the System V ABI, Intel 386
  11    architecture supplement.  */
  12
  13 /* Word aligned, sizeof is 4.  */
  14 struct RightToLeft
  15 {
  16   int j:5;
  17   int k:6;
  18   int m:7;
  19 };
  20
  21 /* Word aligned, sizeof is 12.  */
  22 struct BoundaryAlignment
  23 {
  24   short s:9;
  25   int   j:9;
  26   char  c;
  27   short t:9;
  28   short u:9;
  29   char  d;
  30 };
  31
  32 /* Halfword aligned, sizeof is 2.  */
  33 struct StorageUnitSharing
  34 {
  35   char  c;
  36   short s:8;
  37 };
  38
  39 /* Halfword aligned, sizeof is 2.  */
  40 union Allocation
  41 {
  42   char  c;
  43   short s:8;
  44 };
  45
  46 /* Byte aligned, sizeof is 9.  */
  47 struct Unnamed
  48 {
  49   char  c;
  50   int    :0;
  51   char  d;
  52   short  :9;
  53   char  e;
  54   char   :0;
  55 };
  56
  57 /* Extra struct testing bitfields in larger types.
  58    Doubleword aligned, sizeof is 8.  */
  59 struct LargerTypes
  60 {
  61   long long l:33;
  62   int       i:31;
  63 };
  64
  65
  66 void
  67 passing1 (struct RightToLeft str, int j, int k, int m)
  68 {
  69   assert (str.j == j);
  70   assert (str.k == k);
  71   assert (str.m == m);
  72 }
  73
  74 void
  75 passing2 (struct BoundaryAlignment str, short s, int j, char c, short t,
  76           short u, char d)
  77 {
  78   assert (str.s == s);
  79   assert (str.j == j);
  80   assert (str.c == c);
  81   assert (str.t == t);
  82   assert (str.u == u);
  83   assert (str.d == d);
  84 }
  85
  86 void
  87 passing3 (struct StorageUnitSharing str, char c, short s)
  88 {
  89   assert (str.c == c);
  90   assert (str.s == s);
  91 }
  92
  93 void
  94 passing4 (struct Unnamed str, char c, char d, char e)
  95 {
  96   assert (str.c == c);
  97   assert (str.d == d);
  98   assert (str.e == e);
  99 }
 100
 101 void
 102 passing5 (struct LargerTypes str, long long l, int i)
 103 {
 104   assert (str.l == l);
 105   assert (str.i == i);
 106 }
 107
 108
 109 void
 110 passingU (union Allocation u, char c)
 111 {
 112   assert (u.c == c);
 113   assert (u.s == c);
 114 }
 115
 116
 117 int
 118 main (void)
 119 {
 120   struct RightToLeft str1;
 121   struct BoundaryAlignment str2;
 122   struct StorageUnitSharing str3;
 123   struct Unnamed str4;
 124   struct LargerTypes str5;
 125   union Allocation u;
 126
 127   /* Check sizeof's.  */
 128   check_size(str1, 4);
 129   check_size(str2, 12);
 130   check_size(str3, 2);
 131   check_size(str4, 9);
 132   check_size(str5, 8);
 133   check_size(u, 2);
 134
 135   /* Check alignof's.  */
 136   check_align_lv(str1, 4);
 137   check_align_lv(str2, 4);
 138   check_align_lv(str3, 2);
 139   check_align_lv(str4, 1);
 140   check_align_lv(str5, 4);
 141   check_align_lv(u, 2);
 142
 143   /* Check passing.  */
 144   str1.j = str2.s = str3.c = str4.c = str5.l = 4;
 145   str1.k = str2.j = str3.s = str4.d = str5.i = 5;
 146   str1.m = str2.c = str4.e = 6;
 147   str2.t = 7;
 148   str2.u = 8;
 149   str2.d = 9;
 150   passing1 (str1, 4, 5, 6);
 151   passing2 (str2, 4, 5, 6, 7, 8, 9);
 152   passing3 (str3, 4, 5);
 153   passing4 (str4, 4, 5, 6);
 154   passing5 (str5, 4, 5);
 155
 156   u.c = 5;
 157   passingU (u, 5);
 158   u.s = 6;
 159   passingU (u, 6);
 160
 161   return 0;
 162 }