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 66/* This is used by bitfields.exp to determine if the target understands 67 signed bitfields. */ 68int i; 69 70int main () 71{ 72 /* For each member, set that member to 1, allow gdb to verify that the 73 member (and only that member) is 1, and then reset it back to 0. */ 74 75#ifdef usestubs 76 set_debug_traps(); 77 breakpoint(); 78#endif 79 flags.uc = 1; 80 break1 (); 81 flags.uc = 0; 82 83 flags.s1 = -1; 84 break1 (); 85 flags.s1 = 0; 86 87 flags.u1 = 1; 88 break1 (); 89 flags.u1 = 0; 90 91 flags.s2 = 1; 92 break1 (); 93 flags.s2 = 0; 94 95 flags.u2 = 1; 96 break1 (); 97 flags.u2 = 0; 98 99 flags.s3 = 1; 100 break1 (); 101 flags.s3 = 0; 102 103 flags.u3 = 1; 104 break1 (); 105 flags.u3 = 0; 106 107 flags.s9 = 1; 108 break1 (); 109 flags.s9 = 0; 110 111 flags.u9 = 1; 112 break1 (); 113 flags.u9 = 0; 114 115 flags.sc = 1; 116 break1 (); 117 flags.sc = 0; 118 119 /* Fill alternating fields with all 1's and verify that none of the bits 120 "bleed over" to the other fields. */ 121 122 flags.uc = 0xFF; 123 flags.u1 = 0x1; 124 flags.u2 = 0x3; 125 flags.u3 = 0x7; 126 flags.u9 = 0x1FF; 127 break2 (); 128 flags.uc = 0; 129 flags.u1 = 0; 130 flags.u2 = 0; 131 flags.u3 = 0; 132 flags.u9 = 0; 133 134 flags.s1 = -1; 135 flags.s2 = -1; 136 flags.s3 = -1; 137 flags.s9 = -1; 138 flags.sc = 0xFF; 139 break2 (); 140 flags.s1 = 0; 141 flags.s2 = 0; 142 flags.s3 = 0; 143 flags.s9 = 0; 144 flags.sc = 0; 145 146 /* Fill the unsigned fields with the maximum positive value and verify 147 that the values are printed correctly. */ 148 149 /* Maximum positive values */ 150 flags.u1 = 0x1; 151 flags.u2 = 0x3; 152 flags.u3 = 0x7; 153 flags.u9 = 0x1FF; 154 break3 (); 155 flags.u1 = 0; 156 flags.u2 = 0; 157 flags.u3 = 0; 158 flags.u9 = 0; 159 160 /* Fill the signed fields with the maximum positive value, then the maximally 161 negative value, then -1, and verify in each case that the values are 162 printed correctly. */ 163 164 /* Maximum positive values */ 165 flags.s1 = 0x0; 166 flags.s2 = 0x1; 167 flags.s3 = 0x3; 168 flags.s9 = 0xFF; 169 break4 (); 170 171 /* Maximally negative values */ 172 flags.s1 = -0x1; 173 flags.s2 = -0x2; 174 flags.s3 = -0x4; 175 flags.s9 = -0x100; 176 /* Extract bitfield value so that bitfield.exp can check if the target 177 understands signed bitfields. */ 178 i = flags.s9; 179 break4 (); 180 181 /* -1 */ 182 flags.s1 = -1; 183 flags.s2 = -1; 184 flags.s3 = -1; 185 flags.s9 = -1; 186 break4 (); 187 188 flags.s1 = 0; 189 flags.s2 = 0; 190 flags.s3 = 0; 191 flags.s9 = 0; 192 193 return 0; 194} 195