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
12struct 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
26struct internalvartest
27{
28  unsigned int a : 1;
29  struct
30    {
31      unsigned int b : 1;
32      struct
33	{
34	  unsigned int c : 1;
35	  signed int   d : 1;
36	} deep;
37      signed int   e : 1;
38    } inner;
39  signed int   f : 1;
40} dummy_internalvartest;
41
42void break1 ()
43{
44}
45
46void break2 ()
47{
48}
49
50void break3 ()
51{
52}
53
54void break4 ()
55{
56}
57
58void break5 ()
59{
60}
61
62void break6 ()
63{
64}
65
66void break7 ()
67{
68}
69
70void break8 ()
71{
72}
73
74void break9 ()
75{
76}
77
78void break10 ()
79{
80}
81
82struct container
83{
84  struct fields one;
85  struct fields two;
86} container;
87
88/* This is used by bitfields.exp to determine if the target understands
89   signed bitfields.  */
90int i;
91
92int main ()
93{
94  /* For each member, set that member to 1, allow gdb to verify that the
95     member (and only that member) is 1, and then reset it back to 0. */
96
97  flags.uc = 1;
98  break1 ();
99  flags.uc = 0;
100
101  flags.s1 = -1;
102  break1 ();
103  flags.s1 = 0;
104
105  flags.u1 = 1;
106  break1 ();
107  flags.u1 = 0;
108
109  flags.s2  = 1;
110  break1 ();
111  flags.s2 = 0;
112
113  flags.u2 = 1;
114  break1 ();
115  flags.u2 = 0;
116
117  flags.s3  = 1;
118  break1 ();
119  flags.s3 = 0;
120
121  flags.u3 = 1;
122  break1 ();
123  flags.u3 = 0;
124
125  flags.s9 = 1;
126  break1 ();
127  flags.s9 = 0;
128
129  flags.u9 = 1;
130  break1 ();
131  flags.u9 = 0;
132
133  flags.sc = 1;
134  break1 ();
135  flags.sc = 0;
136
137  /* Fill alternating fields with all 1's and verify that none of the bits
138     "bleed over" to the other fields. */
139
140  flags.uc = 0xFF;
141  flags.u1 = 0x1;
142  flags.u2 = 0x3;
143  flags.u3 = 0x7;
144  flags.u9 = 0x1FF;
145  break2 ();
146  flags.uc = 0;
147  flags.u1 = 0;
148  flags.u2 = 0;
149  flags.u3 = 0;
150  flags.u9 = 0;
151
152  flags.s1 = -1;
153  flags.s2 = -1;
154  flags.s3 = -1;
155  flags.s9 = -1;
156  flags.sc = 0xFF;
157  break2 ();
158  flags.s1 = 0;
159  flags.s2 = 0;
160  flags.s3 = 0;
161  flags.s9 = 0;
162  flags.sc = 0;
163
164  /* Fill the unsigned fields with the maximum positive value and verify
165     that the values are printed correctly. */
166
167  /* Maximum positive values */
168  flags.u1 = 0x1;
169  flags.u2 = 0x3;
170  flags.u3 = 0x7;
171  flags.u9 = 0x1FF;
172  break3 ();
173  flags.u1 = 0;
174  flags.u2 = 0;
175  flags.u3 = 0;
176  flags.u9 = 0;
177
178  /* Fill the signed fields with the maximum positive value, then the maximally
179     negative value, then -1, and verify in each case that the values are
180     printed correctly. */
181
182  /* Maximum positive values */
183  flags.s1 = 0x0;
184  flags.s2 = 0x1;
185  flags.s3 = 0x3;
186  flags.s9 = 0xFF;
187  break4 ();
188
189  /* Maximally negative values */
190  flags.s1 = -0x1;
191  flags.s2 = -0x2;
192  flags.s3 = -0x4;
193  flags.s9 = -0x100;
194  /* Extract bitfield value so that bitfield.exp can check if the target
195     understands signed bitfields.  */
196  i = flags.s9;
197  break4 ();
198
199  /* -1 */
200  flags.s1 = -1;
201  flags.s2 = -1;
202  flags.s3 = -1;
203  flags.s9 = -1;
204  break4 ();
205
206  flags.s1 = 0;
207  flags.s2 = 0;
208  flags.s3 = 0;
209  flags.s9 = 0;
210
211  /* Bitfields at a non-zero offset in a containing structure.  */
212  container.one.u3 = 5;
213  container.two.u3 = 3;
214  break5 ();
215
216  return 0;
217}
218