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