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
26void break1 ()
27{
28}
29
30void break2 ()
31{
32}
33
34void break3 ()
35{
36}
37
38void break4 ()
39{
40}
41
42void break5 ()
43{
44}
45
46void break6 ()
47{
48}
49
50void break7 ()
51{
52}
53
54void break8 ()
55{
56}
57
58void break9 ()
59{
60}
61
62void break10 ()
63{
64}
65
66struct 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.  */
74int i;
75
76int 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}
206