gdb/testsuite/gdb.base/bitfields.c

   1 /* Test program to test bit field operations */
   2
   3 /* For non-ANSI compilers, use plain ints for the signed bit fields.  However,
   4    whether they actually end up signed or not is implementation defined, so
   5    this may cause some tests to fail.  But at least we can still compile
   6    the test program and run the tests... */
   7
   8 #if !defined(__STDC__) && !defined(__cplusplus)
   9 #define signed  /**/
  10 #endif
  11
  12 struct fields
  13 {
  14   unsigned char uc    ;
  15   signed int    s1 : 1;
  16   unsigned int  u1 : 1;
  17   signed int    s2 : 2;
  18   unsigned int  u2 : 2;
  19   signed int    s3 : 3;
  20   unsigned int  u3 : 3;
  21   signed int    s9 : 9;
  22   unsigned int  u9 : 9;
  23   signed char   sc    ;
  24 } flags;
  25
  26 void break1 ()
  27 {
  28 }
  29
  30 void break2 ()
  31 {
  32 }
  33
  34 void break3 ()
  35 {
  36 }
  37
  38 void break4 ()
  39 {
  40 }
  41
  42 void break5 ()
  43 {
  44 }
  45
  46 void break6 ()
  47 {
  48 }
  49
  50 void break7 ()
  51 {
  52 }
  53
  54 void break8 ()
  55 {
  56 }
  57
  58 void break9 ()
  59 {
  60 }
  61
  62 void break10 ()
  63 {
  64 }
  65
  66 struct container
  67 {
  68   struct fields one;
  69   struct fields two;
  70 } container;
  71
  72 /* This is used by bitfields.exp to determine if the target understands
  73    signed bitfields.  */
  74 int i;
  75
  76 int main ()
  77 {
  78   /* For each member, set that member to 1, allow gdb to verify that the
  79      member (and only that member) is 1, and then reset it back to 0. */
  80
  81 #ifdef usestubs
  82   set_debug_traps();
  83   breakpoint();
  84 #endif
  85   flags.uc = 1;
  86   break1 ();
  87   flags.uc = 0;
  88
  89   flags.s1 = -1;
  90   break1 ();
  91   flags.s1 = 0;
  92
  93   flags.u1 = 1;
  94   break1 ();
  95   flags.u1 = 0;
  96
  97   flags.s2  = 1;
  98   break1 ();
  99   flags.s2 = 0;
 100
 101   flags.u2 = 1;
 102   break1 ();
 103   flags.u2 = 0;
 104
 105   flags.s3  = 1;
 106   break1 ();
 107   flags.s3 = 0;
 108
 109   flags.u3 = 1;
 110   break1 ();
 111   flags.u3 = 0;
 112
 113   flags.s9 = 1;
 114   break1 ();
 115   flags.s9 = 0;
 116
 117   flags.u9 = 1;
 118   break1 ();
 119   flags.u9 = 0;
 120
 121   flags.sc = 1;
 122   break1 ();
 123   flags.sc = 0;
 124
 125   /* Fill alternating fields with all 1's and verify that none of the bits
 126      "bleed over" to the other fields. */
 127
 128   flags.uc = 0xFF;
 129   flags.u1 = 0x1;
 130   flags.u2 = 0x3;
 131   flags.u3 = 0x7;
 132   flags.u9 = 0x1FF;
 133   break2 ();
 134   flags.uc = 0;
 135   flags.u1 = 0;
 136   flags.u2 = 0;
 137   flags.u3 = 0;
 138   flags.u9 = 0;
 139
 140   flags.s1 = -1;
 141   flags.s2 = -1;
 142   flags.s3 = -1;
 143   flags.s9 = -1;
 144   flags.sc = 0xFF;
 145   break2 ();
 146   flags.s1 = 0;
 147   flags.s2 = 0;
 148   flags.s3 = 0;
 149   flags.s9 = 0;
 150   flags.sc = 0;
 151
 152   /* Fill the unsigned fields with the maximum positive value and verify
 153      that the values are printed correctly. */
 154
 155   /* Maximum positive values */
 156   flags.u1 = 0x1;
 157   flags.u2 = 0x3;
 158   flags.u3 = 0x7;
 159   flags.u9 = 0x1FF;
 160   break3 ();
 161   flags.u1 = 0;
 162   flags.u2 = 0;
 163   flags.u3 = 0;
 164   flags.u9 = 0;
 165
 166   /* Fill the signed fields with the maximum positive value, then the maximally
 167      negative value, then -1, and verify in each case that the values are
 168      printed correctly. */
 169
 170   /* Maximum positive values */
 171   flags.s1 = 0x0;
 172   flags.s2 = 0x1;
 173   flags.s3 = 0x3;
 174   flags.s9 = 0xFF;
 175   break4 ();
 176
 177   /* Maximally negative values */
 178   flags.s1 = -0x1;
 179   flags.s2 = -0x2;
 180   flags.s3 = -0x4;
 181   flags.s9 = -0x100;
 182   /* Extract bitfield value so that bitfield.exp can check if the target
 183      understands signed bitfields.  */
 184   i = flags.s9;
 185   break4 ();
 186
 187   /* -1 */
 188   flags.s1 = -1;
 189   flags.s2 = -1;
 190   flags.s3 = -1;
 191   flags.s9 = -1;
 192   break4 ();
 193
 194   flags.s1 = 0;
 195   flags.s2 = 0;
 196   flags.s3 = 0;
 197   flags.s9 = 0;
 198
 199   /* Bitfields at a non-zero offset in a containing structure.  */
 200   container.one.u3 = 5;
 201   container.two.u3 = 3;
 202   break5 ();
 203
 204   return 0;
 205 }