Debian Codegraph @

gcc/testsuite/gcc.target/avr/torture/pr119421-sreg.c

raw
1 /* { dg-do run } */
2 /* { dg-additional-options "-std=gnu99 -Wno-pedantic" } */
3
4 #include <stdint.h>
5 #include <stdlib.h>
6 #include <stdbool.h>
7
8 #define BITNO_I 7
9 #define BITNO_T 6
10 #define BITNO_H 5
11 #define BITNO_S 4
12 #define BITNO_V 3
13 #define BITNO_N 2
14 #define BITNO_Z 1
15 #define BITNO_C 0
16
17 #define I (1u << BITNO_I)
18 #define T (1u << BITNO_T)
19 #define H (1u << BITNO_H)
20 #define S (1u << BITNO_S)
21 #define V (1u << BITNO_V)
22 #define N (1u << BITNO_N)
23 #define Z (1u << BITNO_Z)
24 #define C (1u << BITNO_C)
25
26 #define bit(a, x) ((bool) ((a) & (1u << (x))))
27
28 typedef union
29 {
30 uint8_t val;
31 struct
32 {
33 bool c:1;
34 bool z:1;
35 bool n:1;
36 bool v:1;
37 bool s:1;
38 bool h:1;
39 bool t:1;
40 bool i:1;
41 };
42 } sreg_t;
43
44
45 typedef struct
46 {
47 sreg_t sreg;
48 uint8_t mask;
49 uint16_t result;
50 } flags_t;
51
52 flags_t flags_sub (uint8_t d, uint8_t r)
53 {
54 uint8_t res = d - r;
55 bool R7 = bit (res, 7);
56
57 bool Rd7 = bit (d, 7);
58 bool Rd3 = bit (d, 3);
59
60 bool R3 = bit (res, 3);
61 bool Rr7 = bit (r, 7);
62 bool Rr3 = bit (r, 3);
63
64 sreg_t s = { 0 };
65
66 s.v = (Rd7 & !Rr7 & !R7) | (!Rd7 & Rr7 & R7);
67 s.n = R7;
68 s.z = res == 0;
69 s.c = (!Rd7 & Rr7) | (Rr7 & R7) | (R7 & !Rd7);
70 s.h = (!Rd3 & Rr3) | (Rr3 & R3) | (R3 & !Rd3);
71 s.s = s.n ^ s.v;
72
73 return (flags_t) { s, H | S | V | N | Z | C, res };
74 }
75
76 flags_t flags_sbc (uint8_t d, uint8_t r, sreg_t sreg)
77 {
78 uint8_t res = d - r - sreg.c;
79 bool R7 = bit (res, 7);
80
81 bool Rd7 = bit (d, 7);
82 bool Rd3 = bit (d, 3);
83
84 bool R3 = bit (res, 3);
85 bool Rr7 = bit (r, 7);
86 bool Rr3 = bit (r, 3);
87
88 sreg_t s = { 0 };
89
90 s.v = (Rd7 & !Rr7 & !R7) | (!Rd7 & Rr7 & R7);
91 s.n = R7;
92 s.z = (res == 0) & sreg.z;
93 s.c = (!Rd7 & Rr7) | (Rr7 & R7) | (R7 & !Rd7);
94 s.h = (!Rd3 & Rr3) | (Rr3 & R3) | (R3 & !Rd3);
95 s.s = s.n ^ s.v;
96
97 return (flags_t) { s, H | S | V | N | Z | C, res };
98 }
99
100 flags_t flags_neg (uint8_t d)
101 {
102 uint8_t res = -d;
103 bool R7 = bit (res, 7);
104 bool R6 = bit (res, 6);
105 bool R5 = bit (res, 5);
106 bool R4 = bit (res, 4);
107 bool R3 = bit (res, 3);
108 bool R2 = bit (res, 2);
109 bool R1 = bit (res, 1);
110 bool R0 = bit (res, 0);
111
112 bool Rd3 = bit (d, 3);
113
114 sreg_t s = { 0 };
115
116 s.v = R7 & !R6 & !R5 & !R4 & !R3 & !R2 & !R1 & !R0;
117 s.n = R7;
118 s.z = res == 0;
119 s.c = R7 | R6 | R5 | R4 | R3 | R2 | R1 | R0;
120 s.h = R3 | Rd3;
121 s.s = s.n ^ s.v;
122
123 return (flags_t) { s, H | S | V | N | Z | C, res };
124 }
125
126 flags_t flags_ror (uint8_t d, sreg_t sreg)
127 {
128 uint8_t res = (d + 0x100 * sreg.c) >> 1;
129
130 sreg_t s = { 0 };
131
132 s.c = bit (d, 0);
133 s.z = res == 0;
134 s.n = bit (res, 7);
135 s.v = s.n ^ s.c;
136 s.s = s.n ^ s.v;
137
138 return (flags_t) { s, S | V | N | Z | C, res };
139 }
140
141 flags_t flags_add (uint8_t d, uint8_t r)
142 {
143 uint8_t res = d + r;
144 bool R7 = bit (res, 7);
145
146 bool Rd7 = bit (d, 7);
147 bool Rd3 = bit (d, 3);
148
149 bool R3 = bit (res, 3);
150 bool Rr7 = bit (r, 7);
151 bool Rr3 = bit (r, 3);
152
153 sreg_t s = { 0 };
154
155 s.v = (Rd7 & Rr7 & !R7) | (!Rd7 & !Rr7 & R7);
156 s.n = R7;
157 s.z = res == 0;
158 s.c = (Rd7 & Rr7) | (Rr7 & !R7) | (!R7 & Rd7);
159 s.h = (Rd3 & Rr3) | (Rr3 & !R3) | (!R3 & Rd3);
160 s.s = s.n ^ s.v;
161
162 return (flags_t) { s, H | S | V | N | Z | C, res };
163 }
164
165 static inline
166 sreg_t sreg_sub (uint8_t d, uint8_t r, uint8_t sreg, uint8_t result)
167 {
168 __asm ("out __SREG__,%[sreg]" "\n\t"
169 "sub %[d],%[r]" "\n\t"
170 "in %[sreg],__SREG__"
171 : [sreg] "+r" (sreg), [d] "+r" (d)
172 : [r] "r" (r));
173 if (d != result)
174 exit (__LINE__);
175 return (sreg_t) sreg;
176 }
177
178 static inline
179 sreg_t sreg_sbc (uint8_t d, uint8_t r, uint8_t sreg, uint8_t result)
180 {
181 __asm ("out __SREG__,%[sreg]" "\n\t"
182 "sbc %[d],%[r]" "\n\t"
183 "in %[sreg],__SREG__"
184 : [sreg] "+r" (sreg), [d] "+r" (d)
185 : [r] "r" (r));
186 if (d != result)
187 exit (__LINE__);
188 return (sreg_t) sreg;
189 }
190
191 static inline
192 sreg_t sreg_neg (uint8_t d, uint8_t sreg, uint8_t result)
193 {
194 __asm ("out __SREG__,%[sreg]" "\n\t"
195 "neg %[d]" "\n\t"
196 "in %[sreg],__SREG__"
197 : [sreg] "+r" (sreg), [d] "+r" (d));
198 if (d != result)
199 exit (__LINE__);
200 return (sreg_t) sreg;
201 }
202
203 static inline
204 sreg_t sreg_ror (uint8_t d, uint8_t sreg, uint8_t result)
205 {
206 __asm ("out __SREG__,%[sreg]" "\n\t"
207 "ror %[d]" "\n\t"
208 "in %[sreg],__SREG__"
209 : [sreg] "+r" (sreg), [d] "+r" (d));
210 if (d != result)
211 exit (__LINE__);
212 return (sreg_t) sreg;
213 }
214
215 static inline
216 sreg_t sreg_add (uint8_t d, uint8_t r, uint8_t sreg, uint8_t result)
217 {
218 __asm ("out __SREG__,%[sreg]" "\n\t"
219 "add %[d],%[r]" "\n\t"
220 "in %[sreg],__SREG__"
221 : [sreg] "+r" (sreg), [d] "+r" (d)
222 : [r] "r" (r));
223 if (d != result)
224 exit (__LINE__);
225 return (sreg_t) sreg;
226 }
227
228 void test_sub (uint8_t d, uint8_t r, sreg_t sreg)
229 {
230 sreg_t s0 = sreg_sub (d, r, sreg.val, d - r);
231 flags_t f = flags_sub (d, r);
232 if ((f.sreg.val & f.mask) != (s0.val & f.mask))
233 exit (__LINE__);
234 }
235
236 void test_sbc (uint8_t d, uint8_t r, sreg_t sreg)
237 {
238 sreg_t s0 = sreg_sbc (d, r, sreg.val, d - r - sreg.c);
239 flags_t f = flags_sbc (d, r, sreg);
240 if ((f.sreg.val & f.mask) != (s0.val & f.mask))
241 exit (__LINE__);
242 }
243
244 void test_neg (uint8_t d, sreg_t sreg)
245 {
246 sreg_t s0 = sreg_neg (d, sreg.val, -d);
247 flags_t f = flags_neg (d);
248 if ((f.sreg.val & f.mask) != (s0.val & f.mask))
249 exit (__LINE__);
250 }
251
252 void test_add (uint8_t d, uint8_t r, sreg_t sreg)
253 {
254 sreg_t s0 = sreg_add (d, r, sreg.val, d + r);
255 flags_t f = flags_add (d, r);
256 if ((f.sreg.val & f.mask) != (s0.val & f.mask))
257 exit (__LINE__);
258 }
259
260 void test_ror (uint8_t d, sreg_t sreg)
261 {
262 sreg_t s0 = sreg_ror (d, sreg.val, (d + 0x100 * sreg.c) >> 1);
263 flags_t f = flags_ror (d, sreg);
264 if ((f.sreg.val & f.mask) != (s0.val & f.mask))
265 exit (__LINE__);
266 }
267
268 void test_sreg (void)
269 {
270 uint8_t d = 0;
271
272 do
273 {
274 uint8_t r = 0;
275 test_neg (d, (sreg_t) { 0x00 });
276 test_neg (d, (sreg_t) { 0xff });
277
278 test_ror (d, (sreg_t) { 0 });
279 test_ror (d, (sreg_t) { C });
280
281 do
282 {
283 test_add (d, r, (sreg_t) { 0x00 });
284 test_add (d, r, (sreg_t) { 0xff });
285
286 test_sub (d, r, (sreg_t) { 0x00 });
287 test_sub (d, r, (sreg_t) { 0xff });
288
289 test_sbc (d, r, (sreg_t) { 0 });
290 test_sbc (d, r, (sreg_t) { C });
291 test_sbc (d, r, (sreg_t) { Z });
292 test_sbc (d, r, (sreg_t) { C | Z });
293 } while (++r);
294 } while (++d);
295 }
296
297 int main (void)
298 {
299 test_sreg();
300 return 0;
301 }