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 struct 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 break1()42void break1 () 43 { 44 } 45 break2()46void break2 () 47 { 48 } 49 break3()50void break3 () 51 { 52 } 53 break4()54void break4 () 55 { 56 } 57 break5()58void break5 () 59 { 60 } 61 break6()62void break6 () 63 { 64 } 65 break7()66void break7 () 67 { 68 } 69 break8()70void break8 () 71 { 72 } 73 break9()74void break9 () 75 { 76 } 77 break10()78void break10 () 79 { 80 } 81 82 struct 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. */ 90 int i; 91 main()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